radiant 0.6.7 → 0.6.8

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

@@ -45,11 +45,11 @@ module Haml
 
     # Creates a new instace of Haml::Engine that will compile the given
     # template string when <tt>render</tt> is called.
-    # See README.rdoc for available options.
+    # See the Haml module documentation for available options.
     #
     #--
     # When adding options, remember to add information about them
-    # to README.rdoc!
+    # to lib/haml.rb!
     #++
     #
     def initialize(template, options = {})
@@ -61,53 +61,44 @@ module Haml
         :autoclose => %w[meta img link br hr input area param col base],
         :preserve => %w[textarea pre],
 
-        :filters => {
-          'sass' => Haml::Filters::Sass,
-          'plain' => Haml::Filters::Plain,
-          'javascript' => Haml::Filters::Javascript,
-          'preserve' => Haml::Filters::Preserve,
-          'redcloth' => Haml::Filters::RedCloth,
-          'textile' => Haml::Filters::Textile,
-          'markdown' => Haml::Filters::Markdown },
         :filename => '(haml)',
         :line => 1,
         :ugly => false,
         :format => :xhtml,
         :escape_html => false
       }
-      @options[:filters].merge! options.delete(:filters) if options[:filters]
       @options.merge! options
 
       unless [:xhtml, :html4, :html5].include?(@options[:format])
         raise Haml::Error, "Invalid format #{@options[:format].inspect}"
       end
 
-      unless @options[:suppress_eval]
-        @options[:filters].merge!({
-          'erb' => Haml::Filters::ERB,
-          'ruby' => Haml::Filters::Ruby
-        })
-      end
-
-      if @options[:locals]
-        warn <<END
-DEPRECATION WARNING:
-The Haml :locals option is deprecated and will be removed in version 2.0.
-Use the locals option for Haml::Engine#render instead.
-END
-      end
-
-      @template = template.rstrip #String
+      @template = template.rstrip + "\n-#\n-#"
       @to_close_stack = []
       @output_tabs = 0
       @template_tabs = 0
       @index = 0
       @flat_spaces = -1
       @newlines = 0
+      @precompiled = ''
+      @merged_text = ''
+      @tab_change  = 0
+
+      if @template =~ /\A(\s*\n)*[ \t]+\S/
+        raise SyntaxError.new("Indenting at the beginning of the document is illegal.", ($1 || "").count("\n"))
+      end
+
+      if @options[:filters]
+        warn <<END
+DEPRECATION WARNING:
+The Haml :filters option is deprecated and will be removed in version 2.1.
+Filters are now automatically registered.
+END
+      end
 
       precompile
-    rescue Haml::Error
-      $!.backtrace.unshift "#{@options[:filename]}:#{@index + $!.line_offset + @options[:line] - 1}" if @index
+    rescue Haml::Error => e
+      e.backtrace.unshift "#{@options[:filename]}:#{(e.line ? e.line + 1 : @index) + @options[:line] - 1}" if @index
       raise
     end
 
@@ -147,7 +138,6 @@ END
     # but if you're relying on local variables defined in the context of scope,
     # they won't work.
     def render(scope = Object.new, locals = {}, &block)
-      locals = (@options[:locals] || {}).merge(locals)
       buffer = Haml::Buffer.new(scope.instance_variable_get('@haml_buffer'), options_for_buffer)
 
       if scope.is_a?(Binding) || scope.is_a?(Proc)

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

@@ -5,13 +5,12 @@ module Haml
 
     # By default, an error is taken to refer to the line of the template
     # that was being processed when the exception was raised.
-    # However, if line_offset is non-zero, it's added to that line number
-    # to get the line to report for the error.
-    attr_reader :line_offset
+    # However, if line is non-nil, it + 1 is used instead.
+    attr_reader :line
 
-    def initialize(message = nil, line_offset = 0)
+    def initialize(message = nil, line = nil)
       super(message)
-      @line_offset = line_offset
+      @line = line
     end
     # :startdoc:
   end

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

@@ -1,5 +1,6 @@
 require File.dirname(__FILE__) + '/../haml'
 require 'optparse'
+require 'fileutils'
 
 module Haml
   # This module contains code for working with the
@@ -128,8 +129,9 @@ END
           dir = File.join(dir, 'haml')
 
           if File.exists?(dir)
-            puts "Directory #{dir} already exists."
-            exit
+            print "Directory #{dir} already exists, overwrite [y/N]? "
+            exit if gets !~ /y/i
+            FileUtils.rm_rf(dir)
           end
 
           begin

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

@@ -6,6 +6,11 @@ module Haml
   # as well as the base module,
   # Haml::Filters::Base.
   module Filters
+    # Returns a hash of defined filters.
+    def self.defined
+      @defined ||= {}
+    end
+
     # The base module for Haml filters.
     # User-defined filters should be modules including this module.
     #
@@ -28,6 +33,7 @@ module Haml
     #
     module Base
       def self.included(base) # :nodoc:
+        Filters.defined[base.name.split("::").last.downcase] = base
         base.extend(base)
       end
 
@@ -64,11 +70,13 @@ module Haml
           if contains_interpolation?(text)
             return if options[:suppress_eval]
 
-            push_script("#{filter.inspect}.render(#{unescape_interpolation(text)})", false)
+            push_script(<<RUBY, false)
+find_and_preserve(#{filter.inspect}.render(#{unescape_interpolation(text)}))
+RUBY
             return
           end
 
-          rendered = filter.render(text)
+          rendered = Haml::Helpers::find_and_preserve(filter.render(text), precompiler.options[:preserve])
 
           if !options[:ugly]
             push_text(rendered.rstrip.gsub("\n", "\n#{'  ' * @output_tabs}"))
@@ -156,11 +164,28 @@ END
       end
     end
 
+    module Cdata
+      include Base
+
+      def render(text)
+        "<![CDATA[#{("\n" + text).rstrip.gsub("\n", "\n    ")}\n]]>"
+      end
+    end
+
+    module Escaped
+      include Base
+
+      def render(text)
+        Haml::Helpers.html_escape text
+      end
+    end
+
     module Ruby
       include Base
       lazy_require 'stringio'
 
       def compile(precompiler, text)
+        return if precompiler.options[:suppress_eval]
         precompiler.instance_eval do
           push_silent <<-END.gsub("\n", ';')
             _haml_old_stdout = $stdout
@@ -176,19 +201,8 @@ END
     module Preserve
       include Base
 
-      def compile(precompiler, text)
-        text = Haml::Helpers.preserve(text) + "\n"
-
-        precompiler.instance_eval do
-          if contains_interpolation?(text)
-            return if options[:suppress_eval]
-
-            push_silent("_hamlout.buffer << #{unescape_interpolation(text)};")
-            return
-          end
-
-          concat_merged_text(text)
-        end
+      def render(text)
+        Haml::Helpers.preserve text
       end
     end
 
@@ -206,6 +220,7 @@ END
       lazy_require 'erb'
 
       def compile(precompiler, text)
+        return if precompiler.options[:suppress_eval]
         src = ::ERB.new(text).src.sub(/^_erbout = '';/, "").gsub("\n", ';')
         precompiler.send(:push_silent, src)
       end

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

@@ -60,16 +60,18 @@ module Haml
     end
 
     # call-seq:
-    #   find_and_preserve(input)
+    #   find_and_preserve(input, tags = haml_buffer.options[:preserve])
     #   find_and_preserve {...}
     #
-    # Isolates the whitespace-sensitive tags in the string and uses preserve
-    # to convert any endlines inside them into HTML entities for endlines.
-    def find_and_preserve(input = '', &block)
+    # Uses preserve to convert any newlines inside whitespace-sensitive tags
+    # into the HTML entities for endlines.
+    # @tags@ is an array of tags to preserve.
+    # It defaults to the value of the <tt>:preserve</tt> option.
+    def find_and_preserve(input = '', tags = haml_buffer.options[:preserve], &block)
       return find_and_preserve(capture_haml(&block)) if block
 
       input = input.to_s
-      input.gsub(/<(textarea|code|pre)([^>]*)>(.*?)(<\/\1>)/im) do
+      input.gsub(/<(#{tags.map(&Regexp.method(:escape)).join('|')})([^>]*)>(.*?)(<\/\1>)/im) do
         "<#{$1}#{$2}>#{preserve($3)}</#{$1}>"
       end
     end
@@ -84,7 +86,7 @@ module Haml
     def preserve(input = '', &block)
       return preserve(capture_haml(&block)) if block
 
-      input.gsub(/\n/, '&#x000A;').gsub(/\r/, '')
+      input.chomp("\n").gsub(/\n/, '&#x000A;').gsub(/\r/, '')
     end
 
     alias_method :flatten, :preserve
@@ -263,8 +265,8 @@ module Haml
 
     #
     # call-seq:
-    #   haml_tag(name, attributes = {}) {...}
-    #   haml_tag(name, text, attributes = {}) {...}
+    #   haml_tag(name, *flags, attributes = {}) {...}
+    #   haml_tag(name, text, *flags, attributes = {}) {...}
     #
     # Creates an HTML tag with the given name and optionally text and attributes.
     # Can take a block that will be executed
@@ -272,6 +274,11 @@ module Haml
     # If the block is a Haml block or outputs text using puts,
     # the text will be properly indented.
     #
+    # <tt>flags</tt> is a list of symbol flags
+    # like those that can be put at the end of a Haml tag
+    # (<tt>:/</tt>, <tt>:<</tt>, and <tt>:></tt>).
+    # Currently, only <tt>:/</tt> and <tt>:<</tt> are supported.
+    #
     # For example,
     #
     #   haml_tag :table do
@@ -302,34 +309,46 @@ module Haml
     #     </tr>
     #   </table>
     #
-    def haml_tag(name, attributes = {}, alt_atts = {}, &block)
+    def haml_tag(name, *rest, &block)
       name = name.to_s
+      text = rest.shift if rest.first.is_a? String
+      flags = []
+      flags << rest.shift while rest.first.is_a? Symbol
+      attributes = Haml::Precompiler.build_attributes(haml_buffer.html?,
+                                                      haml_buffer.options[:attr_wrapper],
+                                                      rest.shift || {})
+
+      if text.nil? && block.nil? && (haml_buffer.options[:autoclose].include?(name) || flags.include?(:/))
+        puts "<#{name}#{attributes} />"
+        return nil
+      end
 
-      text = nil
-      if attributes.is_a? String
-        text = attributes
-        attributes = alt_atts
+      if flags.include?(:/)
+        raise Error.new("Self-closing tags can't have content.") if text
+        raise Error.new("Illegal nesting: nesting within a self-closing tag is illegal.") if block
       end
 
-      attributes = Haml::Precompiler.build_attributes(
-        haml_buffer.html?, haml_buffer.options[:attr_wrapper], attributes)
+      tag = "<#{name}#{attributes}>"
+      if block.nil?
+        tag << text.to_s << "</#{name}>"
+        puts tag
+        return
+      end
 
-      if text.nil? && block.nil? && haml_buffer.options[:autoclose].include?(name)
-        puts "<#{name}#{attributes} />"
-        return nil
+      if text
+        raise Error.new("Illegal nesting: content can't be both given to haml_tag :#{name} and nested within it.")
       end
 
-      puts "<#{name}#{attributes}>"
-      unless text && text.empty?
-        tab_up
-        # Print out either the text (using push_text) or call the block and add an endline
-        if text
-          puts(text)
-        elsif block
-          block.call
-        end
-        tab_down
+      if flags.include?(:<)
+        tag << capture_haml(&block).strip << "</#{name}>"
+        puts tag
+        return
       end
+
+      puts tag
+      tab_up
+      block.call
+      tab_down
       puts "</#{name}>"
       nil
     end

data/vendor/plugins/haml/lib/haml/helpers/action_view_mods.rb

@@ -7,44 +7,93 @@ if defined?(ActionView) and not defined?(Merb::Plugins)
       end
       alias_method :render_without_haml, :render
       alias_method :render, :render_with_haml
+
+      # Rails >2.1
+      if instance_methods.include?('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 set_output_buffer_with_haml(new)
+          if is_haml?
+            haml_buffer.buffer = new
+          else
+            set_output_buffer_without_haml new
+          end
+        end
+        alias_method :set_output_buffer_without_haml, :output_buffer=
+        alias_method :output_buffer=, :set_output_buffer_with_haml
+      end
     end
 
     # This overrides various helpers in ActionView
     # to make them work more effectively with Haml.
     module Helpers
       # :stopdoc:
-      module CaptureHelper
-        def capture_with_haml(*args, &block)
-          if is_haml?
-            capture_haml(*args, &block)
-          else
-            capture_without_haml(*args, &block)
+      # 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 ActionView::Base.instance_methods.include?('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.
+            block_is_haml =
+              begin
+                eval('_hamlout', block)
+                true
+              rescue
+                false
+              end
+
+            if block_is_haml && is_haml?
+              capture_haml(*args, &block)
+            else
+              capture_without_haml(*args, &block)
+            end
           end
-        end
-        alias_method :capture_without_haml, :capture
-        alias_method :capture, :capture_with_haml
+          alias_method :capture_without_haml, :capture
+          alias_method :capture, :capture_with_haml
 
-        def capture_erb_with_buffer_with_haml(*args, &block)
-          if is_haml?
-            capture_haml_with_buffer(*args, &block)
-          else
-            capture_erb_with_buffer_without_haml(*args, &block)
+          def capture_erb_with_buffer_with_haml(*args, &block)
+            if is_haml?
+              capture_haml_with_buffer(*args, &block)
+            else
+              capture_erb_with_buffer_without_haml(*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
-        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)
+        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 is_haml?
+              capture_haml(*args, &block)
+            else
+              capture_without_haml(*args, &block)
+            end
           end
+          alias_method :capture_without_haml, :capture
+          alias_method :capture, :capture_with_haml
         end
-        alias_method :concat_without_haml, :concat
-        alias_method :concat, :concat_with_haml
       end
 
       module TagHelper