radiant 0.9.0.rc2 → 0.9.1

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

@@ -97,28 +97,57 @@ end
 
 module ActionView
   module Helpers
+    module CaptureHelper
+      def with_output_buffer_with_haml_xss(*args, &block)
+        res = with_output_buffer_without_haml_xss(*args, &block)
+        case res
+        when Array; res.map {|s| Haml::Util.html_safe(s)}
+        when String; Haml::Util.html_safe(res)
+        else; res
+        end
+      end
+      alias_method :with_output_buffer_without_haml_xss, :with_output_buffer
+      alias_method :with_output_buffer, :with_output_buffer_with_haml_xss
+    end
+
+    module FormTagHelper
+      def form_tag_with_haml_xss(*args, &block)
+        Haml::Util.html_safe(form_tag_without_haml_xss(*args, &block))
+      end
+      alias_method :form_tag_without_haml_xss, :form_tag
+      alias_method :form_tag, :form_tag_with_haml_xss
+    end
+
+    module FormHelper
+      def form_for_with_haml_xss(*args, &block)
+        Haml::Util.html_safe(form_for_without_haml_xss(*args, &block))
+      end
+      alias_method :form_for_without_haml_xss, :form_for
+      alias_method :form_for, :form_for_with_haml_xss
+    end
+
     module TextHelper
-      def concat_with_haml(string)
+      def concat_with_haml_xss(string)
         if is_haml?
           haml_buffer.buffer.concat(haml_xss_html_escape(string))
         else
-          concat_without_haml(string)
+          concat_without_haml_xss(string)
         end
       end
-      alias_method :concat_without_haml, :concat
-      alias_method :concat, :concat_with_haml
+      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(string)
+        def safe_concat_with_haml_xss(string)
           if is_haml?
             haml_buffer.buffer.concat(string)
           else
-            safe_concat_without_haml(string)
+            safe_concat_without_haml_xss(string)
           end
         end
-        alias_method :safe_concat_without_haml, :safe_concat
-        alias_method :safe_concat, :safe_concat_with_haml
+        alias_method :safe_concat_without_haml_xss, :safe_concat
+        alias_method :safe_concat, :safe_concat_with_haml_xss
       end
     end
   end

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

@@ -68,7 +68,7 @@ module Haml
   #
   # Example usage:
   #
-  #     Haml::Engine.new("<a href='http://google.com'>Blat</a>").render
+  #     Haml::HTML.new("<a href='http://google.com'>Blat</a>").render
   #       #=> "%a{:href => 'http://google.com'} Blat"
   class HTML
     # @param template [String, Hpricot::Node] The HTML template to convert

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

@@ -146,6 +146,7 @@ END
     class Line < Struct.new(:text, :unstripped, :full, :index, :precompiler, :eod)
       alias_method :eod?, :eod
 
+      # @private
       def tabs
         line = self
         @tabs ||= precompiler.instance_eval do
@@ -189,7 +190,6 @@ END
         if flat?
           push_flat(@line)
           @line = @next_line
-          newline
           next
         end
 
@@ -245,11 +245,12 @@ END
         return start_haml_comment if text[1] == SILENT_COMMENT
 
         raise SyntaxError.new(<<END.rstrip, index) if text[1..-1].strip == "end"
-You don't need to use "- end" in Haml. Use indentation instead:
+You don't need to use "- end" in Haml. Un-indent to close a block:
 - if foo?
   %strong Foo!
 - else
   Not foo.
+%p This line is un-indented, so it isn't part of the "if" block
 END
 
         push_silent(text[1..-1], true)

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

@@ -0,0 +1,18 @@
+# This file is here to integrate with Rails 3,
+# since there's no better way to do so as of 14 March 2010.
+# Yehuda promises there will be soon,
+# and once there is we should switch to that.
+
+if defined?(ActiveSupport) && Haml::Util.has?(:public_method, ActiveSupport, :on_load)
+  # Rails 3.0.0.beta.2+
+  ActiveSupport.on_load(:action_view) {Haml.init_rails(binding)}
+elsif defined?(Rails::Railtie)
+  # Rails 3.0.0.beta1
+  module Haml
+    class Railtie < Rails::Railtie
+      initializer :haml do
+        Haml.init_rails(binding)
+      end
+    end
+  end
+end

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

@@ -1,4 +1,6 @@
 require 'haml/engine'
+require 'haml/helpers/action_view_mods'
+require 'haml/helpers/action_view_extensions'
 
 module Haml
   # The class that keeps track of the global options for Haml within Rails.
@@ -17,7 +19,11 @@ module Haml
     #
     # @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?
+      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
 
@@ -46,16 +52,21 @@ 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::Handler)
+if defined?(ActionView::TemplateHandler) ||
+    (defined?(ActionView::Template) && defined?(ActionView::Template::Handler))
   require 'haml/template/plugin'
 else
   require 'haml/template/patch'
 end
 
-# Enable XSS integration. Use Rails' after_initialize method if possible
+# 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 defined?(Rails.configuration.after_initialize)
+#
+# 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

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

@@ -3,8 +3,11 @@
 
 module Haml
   class Plugin < Haml::Util.av_template_class(:Handler)
-    if defined?(ActionView::TemplateHandlers::Compilable) ||
-        defined?(ActionView::Template::Handlers::Compilable)
+    if (defined?(ActionView::TemplateHandlers) &&
+        defined?(ActionView::TemplateHandlers::Compilable)) ||
+       (defined?(ActionView::Template) &&
+        defined?(ActionView::Template::Handlers) &&
+        defined?(ActionView::Template::Handlers::Compilable))
       include Haml::Util.av_template_class(:Handlers)::Compilable
     end
 
@@ -30,6 +33,38 @@ 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 precompiler 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 Precompiler
+      def push_silent_with_haml_block_deprecation(text, can_suppress = false)
+        unless can_suppress && block_opened? && !mid_block_keyword?("- #{text}") &&
+            text =~ ActionView::Template::Handlers::Erubis::BLOCK_EXPR
+          return push_silent_without_haml_block_deprecation(text, can_suppress)
+        end
+
+        push_silent_without_haml_block_deprecation("_hamlout.append_if_string= #{text}", can_suppress)
+      end
+      alias_method :push_silent_without_haml_block_deprecation, :push_silent
+      alias_method :push_silent, :push_silent_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

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

@@ -157,6 +157,55 @@ module Haml
       return nil
     end
 
+    # Returns whether this environment is using ActionPack
+    # version 3.0.0 or greater.
+    #
+    # @return [Boolean]
+    def ap_geq_3?
+      # The ActionPack module is always loaded automatically in Rails >= 3
+      return false unless defined?(ActionPack) && defined?(ActionPack::VERSION)
+
+      version =
+        if defined?(ActionPack::VERSION::MAJOR)
+          ActionPack::VERSION::MAJOR
+        else
+          # Rails 1.2
+          ActionPack::VERSION::Major
+        end
+
+      # 3.0.0.beta1 acts more like ActionPack 2
+      # for purposes of this method
+      # (checking whether block helpers require = or -).
+      # This extra check can be removed when beta2 is out.
+      version >= 3 &&
+        !(defined?(ActionPack::VERSION::TINY) &&
+          ActionPack::VERSION::TINY == "0.beta")
+    end
+
+    # Returns whether this environment is using ActionPack
+    # version 3.0.0.beta.3 or greater.
+    #
+    # @return [Boolean]
+    def ap_geq_3_beta_3?
+      # The ActionPack module is always loaded automatically in Rails >= 3
+      return false unless defined?(ActionPack) && defined?(ActionPack::VERSION)
+
+      version =
+        if defined?(ActionPack::VERSION::MAJOR)
+          ActionPack::VERSION::MAJOR
+        else
+          # Rails 1.2
+          ActionPack::VERSION::Major
+        end
+      version >= 3 &&
+        ((defined?(ActionPack::VERSION::TINY) &&
+          ActionPack::VERSION::TINY.is_a?(Fixnum) &&
+          ActionPack::VERSION::TINY >= 1) ||
+         (defined?(ActionPack::VERSION::BUILD) &&
+          ActionPack::VERSION::BUILD =~ /beta(\d+)/ &&
+          $1.to_i >= 3))
+    end
+
     # Returns an ActionView::Template* class.
     # In pre-3.0 versions of Rails, most of these classes
     # were of the form `ActionView::TemplateFoo`,
@@ -185,9 +234,10 @@ module Haml
     # With older versions of the Rails XSS-safety mechanism,
     # this destructively modifies the HTML-safety of `text`.
     #
-    # @param text [String]
-    # @return [String] `text`, marked as HTML-safe
+    # @param text [String, nil]
+    # @return [String, nil] `text`, marked as HTML-safe
     def html_safe(text)
+      return unless text
       return text.html_safe if defined?(ActiveSupport::SafeBuffer)
       text.html_safe!
     end
@@ -201,6 +251,10 @@ module Haml
       raise Haml::Error.new("Expected #{text.inspect} to be HTML-safe.")
     end
 
+    # The class for the Rails SafeBuffer XSS protection class.
+    # This varies depending on Rails version.
+    #
+    # @return [Class]
     def rails_safe_buffer_class
       return ActionView::SafeBuffer if defined?(ActionView::SafeBuffer)
       ActiveSupport::SafeBuffer

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

@@ -38,27 +38,42 @@ module Haml
       @@version[:number] = [:major, :minor, :teeny].map { |comp| @@version[comp] }.compact.join('.')
       @@version[:string] = @@version[:number].dup
 
-      if File.exists?(scope('REVISION'))
-        rev = File.read(scope('REVISION')).strip
-        rev = nil if rev !~ /^([a-f0-9]+|\(.*\))$/
-      end
-
-      if (rev.nil? || rev == '(unknown)') && File.exists?(scope('.git/HEAD'))
-        rev = File.read(scope('.git/HEAD')).strip
-        if rev =~ /^ref: (.*)$/
-          rev = File.read(scope(".git/#{$1}")).strip
-        end
-      end
-
-      if rev
+      if rev = revision_number
         @@version[:rev] = rev
         unless rev[0] == ?(
           @@version[:string] << "." << rev[0...7]
         end
-        @@version[:string] << " (#{name})"
       end
 
+      @@version[:string] << " (#{name})"
       @@version
     end
+
+    private
+
+    def revision_number
+      if File.exists?(scope('REVISION'))
+        rev = File.read(scope('REVISION')).strip
+        return rev unless rev =~ /^([a-f0-9]+|\(.*\))$/ || rev == '(unknown)'
+      end
+
+      return unless File.exists?(scope('.git/HEAD'))
+      rev = File.read(scope('.git/HEAD')).strip
+      return rev unless rev =~ /^ref: (.*)$/
+
+      ref_name = $1
+      ref_file = scope(".git/#{ref_name}")
+      info_file = scope(".git/info/refs")
+      return File.read(ref_file).strip if File.exists?(ref_file)
+      return unless File.exists?(info_file)
+      File.open(info_file) do |f|
+        f.each do |l|
+          sha, ref = l.strip.split("\t", 2)
+          next unless ref == ref_name
+          return sha
+        end
+      end
+      return nil
+    end
   end
 end

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

@@ -85,7 +85,15 @@ If you really need #{filename}.css, import it explicitly.
 END
         return filename + '.css'
       end
-      raise SyntaxError.new("File to import not found or unreadable: #{original_filename}.", @line)
+
+      message = "File to import not found or unreadable: #{original_filename}.\n"
+      if load_paths.size == 1
+        message << "Load path: #{load_paths.first}"
+      else
+        message << "Load paths:\n  " << load_paths.join("\n  ")
+      end
+
+      raise SyntaxError.new(message, @line)
     end
 
     private
@@ -104,7 +112,7 @@ END
         return unless f.readline("\n").strip == sha
         return Marshal.load(f.read)
       end
-    rescue TypeError, ArgumentError => e
+    rescue EOFError, TypeError, ArgumentError => e
       warn "Warning. Error encountered while reading cache #{compiled_filename}: #{e}"
     end
 

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

@@ -204,8 +204,13 @@ END
 
     def dependency_updated?(css_mtime)
       lambda do |dep|
-        File.mtime(dep) > css_mtime ||
-          dependencies(dep).any?(&dependency_updated?(css_mtime))
+        begin
+          File.mtime(dep) > css_mtime ||
+            dependencies(dep).any?(&dependency_updated?(css_mtime))
+        rescue Sass::SyntaxError
+          # If there's an error finding depenencies, default to recompiling.
+          true
+        end
       end
     end
 

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

@@ -48,12 +48,12 @@ module Sass
       # This is automatically done once the Rack plugin is activated.
       # This is done so that the stylesheets aren't checked twice for each request.
       def self.disable_native_plugin!
-        if defined?(Merb::Rack::Application) &&
+        if defined?(Merb::Rack) && defined?(Merb::Rack::Application) &&
             Haml::Util.has?(:instance_method, Merb::Rack::Application, :call_without_sass)
           Merb::Rack::Application.instance_eval {alias_method :call, :call_without_sass}
         end
 
-        if defined?(ActionDispatch::Callbacks.to_prepare)
+        if defined?(ActionDispatch::Callbacks) && defined?(ActionDispatch::Callbacks.to_prepare)
           ActionDispatch::Callbacks.skip_callback(:prepare, :__sass_process)
         elsif defined?(ActionController::Base) &&
             Haml::Util.has?(:instance_method, ActionController::Base, :sass_old_process)

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

@@ -7,7 +7,8 @@ unless defined?(Sass::RAILS_LOADED)
                               :always_check      => Haml::Util.rails_env != "production",
                               :full_exception    => Haml::Util.rails_env != "production")
 
-  if defined?(ActionDispatch::Callbacks.to_prepare)
+  if defined?(ActionDispatch::Callbacks) &&
+      defined?(ActionDispatch::Callbacks.to_prepare)
     # Rails >= 3.0.0
     ActionDispatch::Callbacks.to_prepare(:sass_process) {Sass::Plugin.check_for_updates}
   else

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

@@ -106,7 +106,7 @@ module Sass::Script
     # @raise [NoMethodError] if `other` is an invalid type
     def times(other)
       if other.is_a? Number
-        self.operate(other, :*)
+        operate(other, :*)
       elsif other.is_a? Color
         other.times(self)
       else
@@ -284,7 +284,7 @@ module Sass::Script
                  end, num_units, den_units)
     end
 
-    protected
+    private
 
     def operate(other, operation)
       this = self