radiant 0.6.7 → 0.6.8

data/vendor/plugins/haml/REVISION

@@ -0,0 +1 @@
+(release)

data/vendor/plugins/haml/Rakefile

@@ -1,38 +1,27 @@
 require 'rubygems'
 require 'rake'
 
-volatile_requires = ['rcov/rcovtask']
-not_loaded = []
-volatile_requires.each do |file|
-  begin
-    require file
-  rescue LoadError
-    not_loaded.push file
-  end
-end
-
 # ----- Benchmarking -----
 
-temp_desc = <<END
+desc <<END
 Benchmark haml against ERb.
-  TIMES=n sets the number of runs. Defaults to 100.
+  TIMES=n sets the number of runs. Defaults to 1000.
 END
-
-desc temp_desc.chomp
 task :benchmark do
   sh "ruby test/benchmark.rb #{ENV['TIMES']}"
 end
 
 # ----- Default: Testing ------
 
-desc 'Default: run unit tests.'
 task :default => :test
 
 require 'rake/testtask'
 
 Rake::TestTask.new do |t|
   t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
+  test_files = FileList['test/**/*_test.rb']
+  test_files.exclude('test/rails/*')
+  t.test_files = test_files
   t.verbose = true
 end
 Rake::Task[:test].send(:add_comment, <<END)
@@ -42,7 +31,6 @@ END
 # ----- Packaging -----
 
 require 'rake/gempackagetask'
-require 'lib/haml'
 load    'haml.gemspec'
 
 Rake::GemPackageTask.new(HAML_GEMSPEC) do |pkg|
@@ -53,8 +41,9 @@ Rake::GemPackageTask.new(HAML_GEMSPEC) do |pkg|
   end
 end
 
-desc "This is an internal task."
 task :revision_file do
+  require 'lib/haml'
+
   if Haml.version[:rev] && !Rake.application.top_level_tasks.include?('release')
     File.open('REVISION', 'w') { |f| f.puts Haml.version[:rev] }
   elsif Rake.application.top_level_tasks.include?('release')
@@ -66,13 +55,15 @@ end
 Rake::Task[:package].prerequisites.insert(0, :revision_file)
 
 # We also need to get rid of this file after packaging.
-Rake::Task[:package].enhance { File.delete('REVISION') if File.exists?('REVISION') }
+at_exit { File.delete('REVISION') rescue nil }
 
+desc "Install Haml as a gem."
 task :install => [:package] do
   sudo = RUBY_PLATFORM =~ /win32/ ? '' : 'sudo'
   sh %{#{sudo} gem install --no-ri pkg/haml-#{File.read('VERSION').strip}}
 end
 
+desc "Release a new Haml package to Rubyforge. Requires the NAME and VERSION flags."
 task :release => [:package] do
   name, version = ENV['NAME'], ENV['VERSION']
   raise "Must supply NAME and VERSION for release task." unless name && version
@@ -91,35 +82,26 @@ rescue LoadError
   require 'rake/rdoctask'
 end
 
-rdoc_task = Proc.new do |rdoc|
+Rake::RDocTask.new do |rdoc|
   rdoc.title    = 'Haml/Sass'
   rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include(*FileList.new('*') do |list|
+                            list.exclude(/(^|[^.a-z])[a-z]+/)
+                            list.exclude('TODO')
+                          end.to_a)
   rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.exclude('TODO')
   rdoc.rdoc_files.exclude('lib/haml/buffer.rb')
   rdoc.rdoc_files.exclude('lib/sass/tree/*')
-end
-
-Rake::RDocTask.new do |rdoc|
-  rdoc_task.call(rdoc)
   rdoc.rdoc_dir = 'rdoc'
-end
-
-Rake::RDocTask.new(:rdoc_devel) do |rdoc|
-  rdoc_task.call(rdoc)
-  rdoc.rdoc_dir = 'rdoc_devel'
-  rdoc.options << '--all'
-  rdoc.rdoc_files.include('test/*.rb')
-
-  # Get rid of exclusion rules
-  rdoc.rdoc_files = Rake::FileList.new(*rdoc.rdoc_files.to_a)
-  rdoc.rdoc_files.include('lib/haml/buffer.rb')
-  rdoc.rdoc_files.include('lib/sass/tree/*')
+  rdoc.main = 'README.rdoc'
 end
 
 # ----- Coverage -----
 
-unless not_loaded.include? 'rcov/rcovtask'
+begin
+  require 'rcov/rcovtask'
+
   Rcov::RcovTask.new do |t|
     t.test_files = FileList['test/**/*_test.rb']
     t.rcov_opts << '-x' << '"^\/"'
@@ -128,31 +110,41 @@ unless not_loaded.include? 'rcov/rcovtask'
     end
     t.verbose = true
   end
-end
+rescue LoadError; end
 
 # ----- Profiling -----
 
-temp_desc = <<-END
-  Run a profile of haml.
-    ENGINE=str sets the engine to be profiled (Haml or Sass).
-    TIMES=n sets the number of runs. Defaults to 100.
-    FILE=n sets the file to profile. Defaults to 'standard'.
-  END
-desc temp_desc.chomp
-task :profile do
-  require 'test/profile'
-
-  engine = ENV['ENGINE'] && ENV['ENGINE'].downcase == 'sass' ? Sass : Haml
-
-  puts '-'*51, "Profiling #{engine}", '-'*51
-
-  args = []
-  args.push ENV['TIMES'].to_i if ENV['TIMES']
-  args.push ENV['FILE'] if ENV['FILE']
-
-  profiler = engine::Profiler.new
-  res = profiler.profile(*args)
-  puts res
+begin
+  require 'ruby-prof'
+
+  desc <<END
+Run a profile of haml.
+  ENGINE=str sets the engine to be profiled. Defaults to Haml.
+  TIMES=n sets the number of runs. Defaults to 1000.
+  FILE=str sets the file to profile.
+    Defaults to 'standard' for Haml and 'complex' for Sass.
+  OUTPUT=str sets the ruby-prof output format.
+    Can be Flat, CallInfo, or Graph. Defaults to Flat. Defaults to Flat.
+END
+  task :profile do
+    engine = (ENV['ENGINE'] || 'haml').downcase
+    times  = (ENV['TIMES'] || '1000').to_i
+    file   = ENV['FILE']
+
+    if engine == 'sass'
+      require 'lib/sass'
+
+      file = File.read("#{File.dirname(__FILE__)}/test/sass/templates/#{file || 'complex'}.sass")
+      result = RubyProf.profile { times.times { Sass::Engine.new(file).render } }
+    else
+      require 'lib/haml'
+
+      file = File.read("#{File.dirname(__FILE__)}/test/haml/templates/#{file || 'standard'}.haml")
+      obj = Object.new
+      Haml::Engine.new(file).def_method(obj, :render)
+      result = RubyProf.profile { times.times { obj.render } }
+    end
 
-  puts '-'*51
-end
+    RubyProf.const_get("#{(ENV['OUTPUT'] || 'Flat').capitalize}Printer").new(result).print 
+  end
+rescue LoadError; end

data/vendor/plugins/haml/VERSION

@@ -1 +1 @@
-1.9.0
+2.0.1

data/vendor/plugins/haml/init.rb

@@ -1,2 +1,7 @@
-require 'haml'
+begin
+  require File.join(File.dirname(__FILE__), 'lib', 'haml') # From here
+rescue LoadError
+  require 'haml' # From gem
+end
+
 Haml.init_rails(binding)

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

@@ -342,6 +342,61 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #     </div>
 #   </div>
 #
+# ==== > and <
+#
+# <tt>></tt> and <tt><</tt> give you more control over the whitespace near a tag.
+# <tt>></tt> will remove all whitespace surrounding a tag,
+# while <tt><</tt> will remove all whitespace immediately within a tag.
+# You can think of them as alligators eating the whitespace:
+# <tt>></tt> faces out of the tag and eats the whitespace on the outside,
+# and <tt><</tt> faces into the tag and eats the whitespace on the inside.
+# They're placed at the end of a tag definition,
+# after class, id, and attribute declarations
+# but before <tt>/</tt> or <tt>=</tt>.
+# For example:
+#
+#   %blockquote<
+#     %div
+#       Foo!
+#
+# is compiled to:
+#
+#   <blockquote><div>
+#     Foo!
+#   </div></blockquote>
+#
+# And:
+#
+#   %img
+#   %img>
+#   %img
+#
+# is compiled to:
+#
+#   <img /><img /><img />
+#
+# And:
+#
+#  %p<= "Foo\nBar"
+#
+# is compiled to:
+#
+#  <p>Foo
+#  Bar</p>
+#
+# And finally:
+#
+#   %img
+#   %pre><
+#     foo
+#     bar
+#   %img
+#
+# is compiled to:
+#
+#   <img /><pre>foo
+#   bar</pre><img />
+#
 # ==== =
 #
 # <tt>=</tt> is placed at the end of a tag definition,
@@ -600,6 +655,9 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 # [javascript] Surrounds the filtered text with <script> and CDATA tags.
 #              Useful for including inline Javascript.
 #
+# [escaped]    Works the same as plain, but HTML-escapes the text
+#              before placing it in the document.
+#
 # [ruby]       Parses the filtered text with the normal Ruby interpreter.
 #              All output sent to <tt>$stdout</tt>, like with +puts+,
 #              is output into the Haml document.
@@ -630,7 +688,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #              is installed
 #              (BlueCloth takes precedence if both are installed).
 #
-# You can also define your own filters (see Setting Options, below).
+# You can also define your own filters (see Haml::Filters).
 #
 # === Ruby evaluators
 #
@@ -856,9 +914,16 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #
 # === Haml Options
 #
-# Options can be set by setting the hash <tt>Haml::Template.options</tt>
-# from <tt>environment.rb</tt> in Rails,
-# or by passing an options hash to Haml::Engine.
+# Options can be set by setting the <tt>Haml::Template.options</tt> hash
+# in <tt>environment.rb</tt> in Rails...
+#
+#   Haml::Template.options[:output] = :html5
+#
+# ...or by setting the <tt>Merb::Config[:haml]</tt> hash in <tt>init.rb</tt> in Merb...
+#
+#   Merb::Config[:haml][:output] = :html5
+# 
+# ...or by passing an options hash to Haml::Engine.new.
 # Available options are:
 #
 # [<tt>:output</tt>]        Determines the output format. The default is :xhtml.
@@ -869,7 +934,8 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 # [<tt>:escape_html</tt>]   Sets whether or not to escape HTML-sensitive characters in script.
 #                           If this is true, = behaves like &=;
 #                           otherwise, it behaves like !=.
-#                           <b>Note that this escapes tag attributes.</b>
+#                           Note that if this is set, != should be used for yielding to subtemplates
+#                           and rendering partials.
 #                           Defaults to false.
 #
 # [<tt>:suppress_eval</tt>] Whether or not attribute hashes and Ruby scripts
@@ -893,12 +959,6 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #                           This is useful for inline templates,
 #                           similar to the last argument to Kernel#eval.
 #
-# [<tt>:filters</tt>]       A hash of filters that can be applied to Haml code.
-#                           The keys are the string names of the filters;
-#                           the values are references to the classes of the filters.
-#                           User-defined filters should always have lowercase keys,
-#                           and should have the interface described in Haml::Filters::Base.
-#
 # [<tt>:autoclose</tt>]     A list of tag names that should be automatically self-closed
 #                           if they have no content.
 #                           Defaults to <tt>['meta', 'img', 'link', 'br', 'hr', 'input', 'area', 'param', 'col', 'base']</tt>.
@@ -937,7 +997,7 @@ module Haml
 
     if File.exists?(scope('REVISION'))
       rev = File.read(scope('REVISION')).strip
-      rev = nil if rev !~ /a-f0-9+/
+      rev = nil if rev !~ /[a-f0-9]+/
     end
 
     if rev.nil? && File.exists?(scope('.git/HEAD'))

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

@@ -84,58 +84,70 @@ module Haml
 
     # Renders +text+ with the proper tabulation. This also deals with
     # making a possible one-line tag one line or not.
-    def push_text(text, tab_change = 0)
+    def push_text(text, dont_tab_up = false, tab_change = 0)
       if @tabulation > 0 && !@options[:ugly]
-        # Have to push every line in by the extra user set tabulation
-        text.gsub!(/^/m, '  ' * @tabulation)
+        # Have to push every line in by the extra user set tabulation.
+        # Don't push lines with just whitespace, though,
+        # because that screws up precompiled indentation.
+        text.gsub!(/^(?!\s+$)/m, tabs)
+        text.sub!(tabs, '') if dont_tab_up
       end
 
       @buffer << text
       @real_tabs += tab_change
+      @dont_tab_up_next_line = false
     end
 
     # Properly formats the output of a script that was run in the
     # instance_eval.
-    def push_script(result, preserve_script, close_tag = nil, preserve_tag = false, escape_html = false)
+    def push_script(result, preserve_script, in_tag = false, preserve_tag = false,
+                    escape_html = false, nuke_inner_whitespace = false)
       tabulation = @real_tabs
 
       if preserve_tag
         result = Haml::Helpers.preserve(result)
       elsif preserve_script
-        result = Haml::Helpers.find_and_preserve(result)
+        result = Haml::Helpers.find_and_preserve(result, options[:preserve])
       end
 
-      result = result.to_s
-      while result[-1] == ?\n
-        # String#chomp is slow
-        result = result[0...-1]
+      result = result.to_s.rstrip
+      result = html_escape(result) if escape_html
+
+      has_newline = result.include?("\n")
+      if in_tag && !nuke_inner_whitespace && (@options[:ugly] || !has_newline || preserve_tag)
+        @buffer << result
+        @real_tabs -= 1
+        return
       end
 
-      result = html_escape(result) if escape_html
+      @buffer << "\n" if in_tag && !nuke_inner_whitespace
+
+      # Precompiled tabulation may be wrong
+      if @tabulation > 0 && !in_tag
+        result = tabs + result
+      end
 
-      if close_tag && (@options[:ugly] || !result.include?("\n") || preserve_tag)
-        @buffer << "#{result}</#{close_tag}>\n"
+      if has_newline && !@options[:ugly]
+        result = result.gsub "\n", "\n" + tabs(tabulation)
+
+        # Add tabulation if it wasn't precompiled
+        result = tabs(tabulation) + result if in_tag && !nuke_inner_whitespace
+      end
+      @buffer << "#{result}"
+      @buffer << "\n" unless nuke_inner_whitespace
+
+      if in_tag && !nuke_inner_whitespace
+        # We never get here if @options[:ugly] is true
+        @buffer << tabs(tabulation-1)
         @real_tabs -= 1
-      else
-        if close_tag
-          @buffer << "\n"
-        end
-
-        result = result.gsub(/^/m, tabs(tabulation)) unless @options[:ugly]
-        @buffer << "#{result}\n"
-
-        if close_tag
-          # We never get here if @options[:ugly] is true
-          @buffer << "#{tabs(tabulation-1)}</#{close_tag}>\n"
-          @real_tabs -= 1
-        end
       end
       nil
     end
 
     # Takes the various information about the opening tag for an
     # element, formats it, and adds it to the buffer.
-    def open_tag(name, self_closing, try_one_line, preserve_tag, escape_html, class_id, obj_ref, content, *attributes_hashes)
+    def open_tag(name, self_closing, try_one_line, preserve_tag, escape_html, class_id,
+                 nuke_outer_whitespace, nuke_inner_whitespace, obj_ref, content, *attributes_hashes)
       tabulation = @real_tabs
 
       attributes = class_id
@@ -146,25 +158,20 @@ module Haml
       self.class.merge_attrs(attributes, parse_object_ref(obj_ref)) if obj_ref
 
       if self_closing
-        str = " />\n"
-      elsif try_one_line || preserve_tag
-        str = ">"
+        str = " />" + (nuke_outer_whitespace ? "" : "\n")
       else
-        str = ">\n"
+        str = ">" + (try_one_line || preserve_tag || nuke_inner_whitespace ? "" : "\n")
       end
 
       attributes = Precompiler.build_attributes(html?, @options[:attr_wrapper], attributes)
-      @buffer << "#{@options[:ugly] ? '' : tabs(tabulation)}<#{name}#{attributes}#{str}"
+      @buffer << "#{nuke_outer_whitespace || @options[:ugly] ? '' : tabs(tabulation)}<#{name}#{attributes}#{str}"
 
       if content
-        if @options[:ugly] || !content.include?("\n")
-          @buffer << "#{content}</#{name}>\n"
-        else
-          @buffer << "\n#{tabs(@real_tabs+1)}#{content}\n#{tabs(@real_tabs)}</#{name}>\n"
-        end
-      elsif !self_closing
-        @real_tabs += 1
+        @buffer << "#{content}</#{name}>" << (nuke_outer_whitespace ? "" : "\n")
+        return
       end
+
+      @real_tabs += 1 unless self_closing || nuke_inner_whitespace
     end
 
     def self.merge_attrs(to, from)
@@ -191,8 +198,8 @@ module Haml
 
     @@tab_cache = {}
     # Gets <tt>count</tt> tabs. Mostly for internal use.
-    def tabs(count)
-      tabs = count + @tabulation
+    def tabs(count = 0)
+      tabs = [count + @tabulation, 0].max
       @@tab_cache[tabs] ||= '  ' * tabs
     end