haml 2.0.2 → 2.0.3

data/VERSION

@@ -1 +1 @@
-2.0.2
+2.0.3

data/bin/haml

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
 # The command line Haml parser.
 
-require File.dirname(__FILE__) + '/../lib/haml'
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'haml'
 require 'haml/exec'
 
 opts = Haml::Exec::Haml.new(ARGV)

data/lib/haml.rb

@@ -23,13 +23,10 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #
 # == Using Haml
 #
-# Haml can be used in two ways:
+# Haml can be used in three ways:
 # as a plugin for Ruby on Rails,
-# and as a standalone Ruby module.
-#
-# Sass can be used in several ways:
-# As a template engine for Ruby on Rails or Merb,
-# or as a standalone engine.
+# as a standalone Ruby module,
+# and as a command-line tool.
 # The first step for all of these is to install the Haml gem:
 #
 #   gem install haml
@@ -39,13 +36,15 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #
 #   haml --rails path/to/rails/app
 #
-# Haml is enabled in Merb by default,
-# so Merb users don't have to do anything more.
-#
-# Once it's installed, all view files with the ".haml" extension
-# (or ".html.haml" for Merb or edge Rails)
+# Once it's installed, all view files with the ".html.haml" extension
 # will be compiled using Haml.
 #
+# To run Haml from the commandline, just use
+#
+#   haml input.haml output.html
+#
+# Use <tt>haml --help</tt> for full documentation.
+#
 # You can access instance variables in Haml templates
 # the same way you do in ERb templates.
 # Helper methods are also available in Haml templates.
@@ -606,6 +605,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #     <hoo>
 #       I think this might get pretty long so I should probably make it multiline so it doesn't look awful.
 #     </hoo>
+#     <p>This is short</p>
 #   </whoo>
 #
 # ==== :
@@ -676,17 +676,13 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #
 # [sass]       Parses the filtered text with Sass to produce CSS output.
 #
-# [redcloth]   Parses the filtered text with RedCloth (http://whytheluckystiff.net/ruby/redcloth),
-#              which uses both Textile and Markdown syntax.
-#              Only works if RedCloth is installed.
-#
 # [textile]    Parses the filtered text with Textile (http://www.textism.com/tools/textile).
 #              Only works if RedCloth is installed.
 #
 # [markdown]   Parses the filtered text with Markdown (http://daringfireball.net/projects/markdown).
-#              Only works if RedCloth or BlueCloth (http://www.deveiate.org/projects/BlueCloth)
-#              is installed
-#              (BlueCloth takes precedence if both are installed).
+#              Only works if RDiscount, RPeg-Markdown, Maruku, or BlueCloth are installed.
+#
+# [maruku]     Parses the filtered text with Maruku, which has some non-standard extensions to Markdown.
 #
 # You can also define your own filters (see Haml::Filters).
 #
@@ -917,16 +913,16 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 # 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
+#   Haml::Template.options[:format] = :html5
 #
 # ...or by setting the <tt>Merb::Config[:haml]</tt> hash in <tt>init.rb</tt> in Merb...
 #
-#   Merb::Config[:haml][:output] = :html5
+#   Merb::Config[:haml][:format] = :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.
+# [<tt>:format</tt>]        Determines the output format. The default is :xhtml.
 #                           Other options are :html4 and :html5, which are
 #                           identical to :xhtml except there are no self-closing tags,
 #                           XML prolog is ignored and correct DOCTYPEs are generated.
@@ -1009,7 +1005,8 @@ module Haml
 
     if rev
       @@version[:rev] = rev
-      @@version[:string] << "." << rev[0...7]
+      @@version[:string] << "."
+      @@version[:string] << rev[0...7] unless rev[0] == ?(
     end
 
     @@version

data/lib/haml/buffer.rb

@@ -104,15 +104,15 @@ module Haml
                     escape_html = false, nuke_inner_whitespace = false)
       tabulation = @real_tabs
 
+      result = result.to_s.rstrip
+      result = html_escape(result) if escape_html
+
       if preserve_tag
         result = Haml::Helpers.preserve(result)
       elsif preserve_script
         result = Haml::Helpers.find_and_preserve(result, options[:preserve])
       end
 
-      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

data/lib/haml/engine.rb

@@ -68,6 +68,7 @@ module Haml
         :escape_html => false
       }
       @options.merge! options
+      @index = 0
 
       unless [:xhtml, :html4, :html5].include?(@options[:format])
         raise Haml::Error, "Invalid format #{@options[:format].inspect}"
@@ -77,8 +78,8 @@ module Haml
       @to_close_stack = []
       @output_tabs = 0
       @template_tabs = 0
-      @index = 0
       @flat_spaces = -1
+      @flat = false
       @newlines = 0
       @precompiled = ''
       @merged_text = ''

data/lib/haml/error.rb

@@ -1,6 +1,6 @@
 module Haml
   # An exception raised by Haml code.
-  class Error < Exception
+  class Error < StandardError
     # :stopdoc:
 
     # By default, an error is taken to refer to the line of the template

data/lib/haml/exec.rb

@@ -1,4 +1,3 @@
-require File.dirname(__FILE__) + '/../haml'
 require 'optparse'
 require 'fileutils'
 
@@ -211,6 +210,8 @@ END
       def initialize(args)
         super
         @name = "Haml"
+        @options[:requires] = []
+        @options[:load_paths] = []
       end
 
       def set_opts(opts)
@@ -230,6 +231,14 @@ END
                 'Escape HTML characters (like ampersands and angle brackets) by default.') do
           @options[:for_engine][:escape_html] = true
         end
+
+        opts.on('-r', '--require FILE', "Same as 'ruby -r'.") do |file|
+          @options[:requires] << file
+        end
+
+        opts.on('-I', '--load-path PATH', "Same as 'ruby -I'.") do |path|
+          @options[:load_paths] << path
+        end
       end
 
       def process_result
@@ -246,6 +255,9 @@ END
             puts "Syntax OK"
             return
           end
+
+          @options[:load_paths].each {|p| $LOAD_PATH << p}
+          @options[:requires].each {|f| require f}
           result = engine.to_html
         rescue Exception => e
           raise e if @options[:trace]
@@ -292,6 +304,10 @@ END
           @module_opts[:rhtml] = true
         end
 
+        opts.on('--no-rhtml', "Don't parse RHTML tags.") do
+          @options[:no_rhtml] = true
+        end
+
         opts.on('-x', '--xhtml', 'Parse the input using the more strict XHTML parser.') do
           @module_opts[:xhtml] = true
         end
@@ -305,6 +321,9 @@ END
         input = @options[:input]
         output = @options[:output]
 
+        @module_opts[:rhtml] ||= input.respond_to?(:path) && input.path =~ /\.(rhtml|erb)$/
+        @module_opts[:rhtml] &&= @options[:no_rhtml] != false
+
         output.write(::Haml::HTML.new(input, @module_opts).render)
       end
     end

data/lib/haml/filters.rb

@@ -1,6 +1,3 @@
-# This file contains redefinitions of and wrappers around various text
-# filters so they can be used as Haml filters.
-
 module Haml
   # The module containing the default filters,
   # as well as the base module,
@@ -35,6 +32,7 @@ module Haml
       def self.included(base) # :nodoc:
         Filters.defined[base.name.split("::").last.downcase] = base
         base.extend(base)
+        base.instance_variable_set "@lazy_requires", nil
       end
 
       # Takes a string, the source text that should be passed to the filter,
@@ -47,6 +45,12 @@ module Haml
         raise Error.new("#{self.inspect}#render not defined!")
       end
 
+      # Same as render, but takes the Haml options hash as well.
+      # It's only safe to rely on options made available in Haml::Engine#options_for_buffer.
+      def render_with_options(text, options)
+        render(text)
+      end
+
       def internal_compile(*args) # :nodoc:
         resolve_lazy_requires
         compile(*args)
@@ -71,12 +75,12 @@ module Haml
             return if options[:suppress_eval]
 
             push_script(<<RUBY, false)
-find_and_preserve(#{filter.inspect}.render(#{unescape_interpolation(text)}))
+find_and_preserve(#{filter.inspect}.render_with_options(#{unescape_interpolation(text)}, _hamlout.options))
 RUBY
             return
           end
 
-          rendered = Haml::Helpers::find_and_preserve(filter.render(text), precompiler.options[:preserve])
+          rendered = Haml::Helpers::find_and_preserve(filter.render_with_options(text, precompiler.options), precompiler.options[:preserve])
 
           if !options[:ugly]
             push_text(rendered.rstrip.gsub("\n", "\n#{'  ' * @output_tabs}"))
@@ -97,7 +101,7 @@ RUBY
       # For example:
       #
       #   module Haml::Filters::Markdown
-      #     lazy_require 'bluecloth', 'redcloth'
+      #     lazy_require 'rdiscount', 'peg_markdown', 'maruku', 'bluecloth'
       #
       #     ...
       #   end
@@ -123,7 +127,7 @@ RUBY
           @required = @lazy_requires[-1]
           require @required
         rescue LoadError => e
-          classname = self.class.to_s.gsub(/\w+::/, '')
+          classname = self.name.match(/\w+$/)[0]
 
           if @lazy_requires.size == 1
             raise Error.new("Can't run #{classname} filter; required file '#{@lazy_requires.first}' not found")
@@ -153,9 +157,9 @@ module Haml
     module Javascript
       include Base
 
-      def render(text)
+      def render_with_options(text, options)
         <<END
-<script type='text/javascript'>
+<script type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}>
   //<![CDATA[
     #{text.rstrip.gsub("\n", "\n    ")}
   //]]>
@@ -211,7 +215,7 @@ END
       lazy_require 'sass/engine'
 
       def render(text)
-        ::Sass::Engine.new(text).render
+        ::Sass::Engine.new(text,::Sass::Plugin.engine_options).render
       end
     end
 
@@ -226,36 +230,42 @@ END
       end
     end
 
-    module RedCloth
+    module Textile
       include Base
       lazy_require 'redcloth'
 
       def render(text)
-        ::RedCloth.new(text).to_html
+        ::RedCloth.new(text).to_html(:textile)
       end
     end
+    RedCloth = Textile
 
-    # Uses RedCloth to provide only Textile (not Markdown) parsing
-    module Textile
+    # Uses BlueCloth or RedCloth to provide only Markdown (not Textile) parsing
+    module Markdown
       include Base
-      lazy_require 'redcloth'
+      lazy_require 'rdiscount', 'peg_markdown', 'maruku', 'bluecloth'
 
       def render(text)
-        ::RedCloth.new(text).to_html(:textile)
+        engine = case @required
+                 when 'rdiscount'
+                   RDiscount
+                 when 'peg_markdown'
+                   PEGMarkdown
+                 when 'maruku'
+                   Maruku
+                 when 'bluecloth'
+                   BlueCloth
+                 end
+        engine.new(text).to_html
       end
     end
 
-    # Uses BlueCloth or RedCloth to provide only Markdown (not Textile) parsing
-    module Markdown
+    module Maruku
       include Base
-      lazy_require 'bluecloth', 'redcloth'
+      lazy_require 'maruku'
 
       def render(text)
-        if @required == 'bluecloth'
-          ::BlueCloth.new(text).to_html
-        else
-          ::RedCloth.new(text).to_html(:markdown)
-        end
+        Maruku.new(text).to_html
       end
     end
   end

data/lib/haml/helpers.rb

@@ -397,7 +397,7 @@ module Haml
     def capture_haml_with_buffer(local_buffer, *args, &block)
       position = local_buffer.length
 
-      block.call *args
+      block.call(*args)
 
       captured = local_buffer.slice!(position..-1)
 

data/lib/haml/html.rb

@@ -29,7 +29,7 @@ module Haml
         end
 
         method = @@options[:xhtml] ? Hpricot.method(:XML) : method(:Hpricot)
-        @template = method.call(template)
+        @template = method.call(template.gsub('&', '&'))
       end
     end
 

data/lib/haml/precompiler.rb

@@ -112,16 +112,13 @@ END
     Line = Struct.new(:text, :unstripped, :index, :spaces, :tabs)
 
     def precompile
+      @haml_comment = @dont_indent_next_line = @dont_tab_up_next_text = false
+      @indentation = nil
       old_line = Line.new
       @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? && !flat?
-          newline
-          next
-        end
-
         suppress_render = handle_multiline(old_line) unless flat?
 
         if old_line.text.nil? || suppress_render
@@ -133,6 +130,11 @@ END
 
         process_indent(old_line) unless old_line.text.empty?
 
+        if line.text.empty? && !flat?
+          newline
+          next
+        end
+
         if flat?
           push_flat(old_line)
           old_line = line
@@ -699,13 +701,7 @@ END
     # Starts a filtered block.
     def start_filtered(name)
       raise Error.new("Invalid filter name \":#{name}\".") unless name =~ /^\w+$/
-
-      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
-        raise Error.new("Filter \"#{name}\" is not defined.")
-      end
+      raise Error.new("Filter \"#{name}\" is not defined.") unless filter = Filters.defined[name]
 
       push_and_tabulate([:filtered, filter])
       @flat_spaces = @template_tabs * 2

data/lib/sass.rb

@@ -20,9 +20,10 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #
 # == Using Sass
 #
-# Sass can be used in several ways:
-# As a plugin for Ruby on Rails or Merb,
-# or as a standalone parser.
+# Sass can be used in three ways:
+# as a plugin for Ruby on Rails,
+# as a standalone Ruby module,
+# and as a command-line tool.
 # Sass is bundled with Haml,
 # so if the Haml plugin or RubyGem is installed,
 # Sass will already be installed as a plugin or gem, respectively.
@@ -42,7 +43,7 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #
 # to config/dependencies.rb.
 #
-# Sass templates in Rails and Merb don't quite function in the same way as views,
+# Sass templates in Rails don't quite function in the same way as views,
 # because they don't contain dynamic content,
 # and so only need to be compiled when the template file has been updated.
 # By default (see options, below),
@@ -50,6 +51,12 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 # Then, whenever necessary, they're compiled into corresponding CSS files in public/stylesheets.
 # For instance, public/stylesheets/sass/main.sass would be compiled to public/stylesheets/main.css.
 #
+# To run Sass from the commandline, just use
+#
+#   sass input.sass output.css
+#
+# Use <tt>sass --help</tt> for full documentation.
+# 
 # Using Sass in Ruby code is very simple.
 # After installing the Haml gem,
 # you can use it by running <tt>require "sass"</tt>