haml 1.8.0 → 2.0.3

data/lib/haml/buffer.rb

@@ -6,11 +6,6 @@ module Haml
   class Buffer
     include Haml::Helpers
 
-    # Set the maximum length for a line to be considered a one-liner.
-    # Lines <= the maximum will be rendered on one line,
-    # i.e. <tt><p>Hello world</p></tt>
-    ONE_LINER_LENGTH     = 50
-
     # The string that holds the compiled XHTML. This is aliased as
     # _erbout for compatibility with ERB-specific code.
     attr_accessor :buffer
@@ -18,6 +13,47 @@ module Haml
     # The options hash passed in from Haml::Engine.
     attr_accessor :options
 
+    # The Buffer for the enclosing Haml document.
+    # This is set for partials and similar sorts of nested templates.
+    # It's nil at the top level (see #toplevel?).
+    attr_accessor :upper
+
+    # See #active?
+    attr_writer :active
+
+    # True if the format is XHTML
+    def xhtml?
+      not html?
+    end
+
+    # True if the format is any flavor of HTML
+    def html?
+      html4? or html5?
+    end
+
+    # True if the format is HTML4
+    def html4?
+      @options[:format] == :html4
+    end
+
+    # True if the format is HTML5
+    def html5?
+      @options[:format] == :html5
+    end
+
+    # True if this buffer is a top-level template,
+    # as opposed to a nested partial.
+    def toplevel?
+      upper.nil?
+    end
+
+    # True if this buffer is currently being used to render a Haml template.
+    # However, this returns false if a subtemplate is being rendered,
+    # even if it's a subtemplate of this buffer's template.
+    def active?
+      @active
+    end
+
     # Gets the current tabulation of the document.
     def tabulation
       @real_tabs + @tabulation
@@ -30,9 +66,13 @@ module Haml
     end
 
     # Creates a new buffer.
-    def initialize(options = {})
+    def initialize(upper = nil, options = {})
+      @active = true
+      @upper = upper
       @options = {
-        :attr_wrapper => "'"
+        :attr_wrapper => "'",
+        :ugly => false,
+        :format => :xhtml
       }.merge options
       @buffer = ""
       @tabulation = 0
@@ -44,56 +84,72 @@ 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)
-      if(@tabulation > 0)
-        # Have to push every line in by the extra user set tabulation
-        text.gsub!(/^/m, '  ' * @tabulation)
+    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.
+        # 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}"
+
+      @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, flattened, close_tag = nil)
+    def push_script(result, preserve_script, in_tag = false, preserve_tag = false,
+                    escape_html = false, nuke_inner_whitespace = false)
       tabulation = @real_tabs
-      
-      if flattened
-        result = Haml::Helpers.find_and_preserve(result)
-      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
+
+      if preserve_tag
+        result = Haml::Helpers.preserve(result)
+      elsif preserve_script
+        result = Haml::Helpers.find_and_preserve(result, options[:preserve])
       end
-      
-      if close_tag && Buffer.one_liner?(result)
+
+      has_newline = result.include?("\n")
+      if in_tag && !nuke_inner_whitespace && (@options[:ugly] || !has_newline || preserve_tag)
         @buffer << result
-        @buffer << "</#{close_tag}>\n"
         @real_tabs -= 1
-      else
-        if close_tag
-          @buffer << "\n"
-        end
-        
-        result = result.gsub(/^/m, tabs(tabulation))
-        @buffer << "#{result}\n"
-        
-        if close_tag
-          @buffer << "#{tabs(tabulation-1)}</#{close_tag}>\n"
-          @real_tabs -= 1
-        end
+        return
+      end
+
+      @buffer << "\n" if in_tag && !nuke_inner_whitespace
+
+      # Precompiled tabulation may be wrong
+      if @tabulation > 0 && !in_tag
+        result = tabs + result
+      end
+
+      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
       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, atomic, try_one_line, 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
       attributes_hashes.each do |attributes_hash|
         attributes_hash.keys.each { |key| attributes_hash[key.to_s] = attributes_hash.delete(key) }
@@ -101,65 +157,67 @@ module Haml
       end
       self.class.merge_attrs(attributes, parse_object_ref(obj_ref)) if obj_ref
 
-      if atomic
-        str = " />\n"
-      elsif try_one_line
-        str = ">"
+      if self_closing
+        str = " />" + (nuke_outer_whitespace ? "" : "\n")
       else
-        str = ">\n"
+        str = ">" + (try_one_line || preserve_tag || nuke_inner_whitespace ? "" : "\n")
       end
-      @buffer << "#{tabs(tabulation)}<#{name}#{Precompiler.build_attributes(@options[:attr_wrapper], attributes)}#{str}"
+
+      attributes = Precompiler.build_attributes(html?, @options[:attr_wrapper], attributes)
+      @buffer << "#{nuke_outer_whitespace || @options[:ugly] ? '' : tabs(tabulation)}<#{name}#{attributes}#{str}"
+
       if content
-        if Buffer.one_liner?(content)
-          @buffer << "#{content}</#{name}>\n"
-        else
-          @buffer << "\n#{tabs(@real_tabs+1)}#{content}\n#{tabs(@real_tabs)}</#{name}>\n"
-        end
-      else
-        @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)
       if to['id'] && from['id']
         to['id'] << '_' << from.delete('id')
+      elsif to['id'] || from['id']
+        from['id'] ||= to['id']
       end
 
       if to['class'] && from['class']
         # Make sure we don't duplicate class names
         from['class'] = (from['class'].split(' ') | to['class'].split(' ')).join(' ')
+      elsif to['class'] || from['class']
+        from['class'] ||= to['class']
       end
 
       to.merge!(from)
     end
 
+    private
+
     # Some of these methods are exposed as public class methods
     # so they can be re-used in helpers.
 
-    # Returns whether or not the given value is short enough to be rendered
-    # on one line.
-    def self.one_liner?(value)
-      value.length <= ONE_LINER_LENGTH && value.scan(/\n/).empty?
-    end
-
-    private
-
     @@tab_cache = {}
     # Gets <tt>count</tt> tabs. Mostly for internal use.
-    def tabs(count)
-      tabs = count + @tabulation
-      '  ' * tabs
+    def tabs(count = 0)
+      tabs = [count + @tabulation, 0].max
       @@tab_cache[tabs] ||= '  ' * tabs
     end
 
     # Takes an array of objects and uses the class and id of the first
     # one to create an attributes hash.
+    # The second object, if present, is used as a prefix,
+    # just like you can do with dom_id() and dom_class() in Rails
     def parse_object_ref(ref)
+      prefix = ref[1]
       ref = ref[0]
       # Let's make sure the value isn't nil. If it is, return the default Hash.
       return {} if ref.nil?
       class_name = underscore(ref.class)
       id = "#{class_name}_#{ref.id || 'new'}"
+      if prefix
+        class_name = "#{ prefix }_#{ class_name}"
+        id = "#{ prefix }_#{ id }"
+      end
 
       {'id' => id, 'class' => class_name}
     end

data/lib/haml/engine.rb

@@ -3,7 +3,6 @@ require 'haml/buffer'
 require 'haml/precompiler'
 require 'haml/filters'
 require 'haml/error'
-require 'haml/util'
 
 module Haml
   # This is the class where all the parsing and processing of the Haml
@@ -20,57 +19,87 @@ module Haml
     # Allow reading and writing of the options hash
     attr :options, true
 
+    # This string contains the source code that is evaluated
+    # to produce the Haml document.
+    attr :precompiled, true
+
+    # True if the format is XHTML
+    def xhtml?
+      not html?
+    end
+
+    # True if the format is any flavor of HTML
+    def html?
+      html4? or html5?
+    end
+
+    # True if the format is HTML4
+    def html4?
+      @options[:format] == :html4
+    end
+
+    # True if the format is HTML5
+    def html5?
+      @options[:format] == :html5
+    end
+
     # Creates a new instace of Haml::Engine that will compile the given
     # template string when <tt>render</tt> is called.
-    # See README for available options.
+    # See the Haml module documentation for available options.
     #
     #--
     # When adding options, remember to add information about them
-    # to README!
+    # to lib/haml.rb!
     #++
     #
     def initialize(template, options = {})
       @options = {
         :suppress_eval => false,
         :attr_wrapper => "'",
-        :autoclose => ['meta', 'img', 'link', 'br', 'hr', 'input', 'area'],
-        :filters => {
-          'sass' => Sass::Engine,
-          'plain' => Haml::Filters::Plain,
-          'preserve' => Haml::Filters::Preserve,
-          'redcloth' => Haml::Filters::RedCloth,
-          'textile' => Haml::Filters::Textile,
-          'markdown' => Haml::Filters::Markdown },
-        :filename => '(haml)'
-      }
-      @options.rec_merge! options
 
-      unless @options[:suppress_eval]
-        @options[:filters].merge!({
-          'erb' => ERB,
-          'ruby' => Haml::Filters::Ruby
-        })
-      end
-      @options[:filters].rec_merge! options[:filters] if options[:filters]
+        # Don't forget to update the docs in lib/haml.rb if you update these
+        :autoclose => %w[meta img link br hr input area param col base],
+        :preserve => %w[textarea pre],
 
-      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
+        :filename => '(haml)',
+        :line => 1,
+        :ugly => false,
+        :format => :xhtml,
+        :escape_html => false
+      }
+      @options.merge! options
+      @index = 0
+
+      unless [:xhtml, :html4, :html5].include?(@options[:format])
+        raise Haml::Error, "Invalid format #{@options[:format].inspect}"
       end
 
-      @template = template.strip #String
+      @template = template.rstrip + "\n-#\n-#"
       @to_close_stack = []
       @output_tabs = 0
       @template_tabs = 0
-      @index = 0
       @flat_spaces = -1
+      @flat = false
+      @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}"
+    rescue Haml::Error => e
+      e.backtrace.unshift "#{@options[:filename]}:#{(e.line ? e.line + 1 : @index) + @options[:line] - 1}" if @index
       raise
     end
 
@@ -80,7 +109,7 @@ END
     # If it's a Binding or Proc object,
     # Haml uses it as the second argument to Kernel#eval;
     # otherwise, Haml just uses its #instance_eval context.
-    # 
+    #
     # Note that Haml modifies the evaluation context
     # (either the scope object or the "self" object of the scope binding).
     # It extends Haml::Helpers, and various instance variables are set
@@ -110,8 +139,7 @@ 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(options_for_buffer)
+      buffer = Haml::Buffer.new(scope.instance_variable_get('@haml_buffer'), options_for_buffer)
 
       if scope.is_a?(Binding) || scope.is_a?(Proc)
         scope_object = eval("self", scope)
@@ -125,17 +153,14 @@ END
 
       scope_object.instance_eval do
         extend Haml::Helpers
-        @haml_stack ||= Array.new
-        @haml_stack.push(buffer)
-        @haml_is_haml = true
+        @haml_buffer = buffer
       end
 
-      eval(@precompiled, scope, @options[:filename], 0)
+      eval(@precompiled, scope, @options[:filename], @options[:line])
 
       # Get rid of the current buffer
       scope_object.instance_eval do
-        @haml_stack.pop
-        @haml_is_haml = false
+        @haml_buffer = buffer.upper
       end
 
       buffer.buffer
@@ -172,7 +197,7 @@ END
       end
 
       eval("Proc.new { |*_haml_locals| _haml_locals = _haml_locals[0] || {};" +
-           precompiled_with_ambles(local_names) + "}\n", scope, @options[:filename], 0)
+           precompiled_with_ambles(local_names) + "}\n", scope, @options[:filename], @options[:line])
     end
 
     # Defines a method on +object+
@@ -189,7 +214,7 @@ END
     #
     #   Haml::Engine.new(".upcased= upcase").def_method(String, :upcased_div)
     #   "foobar".upcased_div #=> "<div class='upcased'>FOOBAR</div>\n"
-    # 
+    #
     # The first argument of the defined method is a hash of local variable names to values.
     # However, due to an unfortunate Ruby quirk,
     # the local variables which can be assigned must be pre-declared.
@@ -205,7 +230,7 @@ END
     #   obj = Object.new
     #   Haml::Engine.new("%p= foo").def_method(obj, :render)
     #   obj.render(:foo => "Hello!") #=> NameError: undefined local variable or method `foo'
-    # 
+    #
     # Note that Haml modifies the evaluation context
     # (either the scope object or the "self" object of the scope binding).
     # It extends Haml::Helpers, and various instance variables are set
@@ -214,7 +239,7 @@ END
       method = object.is_a?(Module) ? :module_eval : :instance_eval
 
       object.send(method, "def #{name}(_haml_locals = {}); #{precompiled_with_ambles(local_names)}; end",
-                  @options[:filename], 0)
+                  @options[:filename], @options[:line])
     end
 
     private
@@ -226,9 +251,15 @@ END
     end
 
     # Returns a hash of options that Haml::Buffer cares about.
-    # This should remain loadable form #inspect.
+    # This should remain loadable from #inspect.
     def options_for_buffer
-      {:attr_wrapper => @options[:attr_wrapper]}
+      {
+        :autoclose => @options[:autoclose],
+        :preserve => @options[:preserve],
+        :attr_wrapper => @options[:attr_wrapper],
+        :ugly => @options[:ugly],
+        :format => @options[:format]
+      }
     end
   end
 end

data/lib/haml/error.rb

@@ -1,13 +1,22 @@
 module Haml
-  # The abstract type of exception raised by Haml code.
-  class Error < StandardError; end
+  # An exception raised by Haml code.
+  class Error < StandardError
+    # :stopdoc:
+
+    # 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 is non-nil, it + 1 is used instead.
+    attr_reader :line
+
+    def initialize(message = nil, line = nil)
+      super(message)
+      @line = line
+    end
+    # :startdoc:
+  end
 
   # SyntaxError is the type of exception raised when Haml encounters an
   # ill-formatted document.
   # It's not particularly interesting, except in that it includes Haml::Error.
   class SyntaxError < Haml::Error; end
-
-  # HamlError is the type of exception raised when Haml encounters an error
-  # not of a syntactical nature, such as an undefined Filter.
-  class HamlError < Haml::Error; end
 end

data/lib/haml/exec.rb

@@ -1,5 +1,5 @@
-require File.dirname(__FILE__) + '/../haml'
 require 'optparse'
+require 'fileutils'
 
 module Haml
   # This module contains code for working with the
@@ -21,7 +21,7 @@ module Haml
           @opts.parse!(@args)
 
           process_result
-          
+
           @options
         rescue Exception => e
           raise e if e.is_a? SystemExit
@@ -43,9 +43,13 @@ module Haml
       protected
 
       def get_line(exception)
+        # SyntaxErrors have weird line reporting
+        # when there's trailing whitespace,
+        # which there is for Haml documents.
+        return exception.message.scan(/:(\d+)/)[0] if exception.is_a?(::SyntaxError)
         exception.backtrace[0].scan(/:(\d+)/)[0]
       end
-      
+
       private
 
       def set_opts(opts)
@@ -63,7 +67,7 @@ module Haml
         end
 
         opts.on_tail("-v", "--version", "Print version") do
-          puts("Haml " + File.read(File.dirname(__FILE__) + '/../../VERSION'))
+          puts("Haml #{::Haml.version[:string]}")
           exit
         end
       end
@@ -110,7 +114,7 @@ Description:
 
 Options:
 END
-       
+
         opts.on('--rails RAILS_DIR', "Install Haml and Sass from the Gem to a Rails project") do |dir|
           original_dir = dir
 
@@ -124,8 +128,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
@@ -145,6 +150,7 @@ END
         end
 
         opts.on('-c', '--check', "Just check syntax, don't evaluate.") do
+          require 'stringio'
           @options[:check_syntax] = true
           @options[:output] = StringIO.new
         end
@@ -170,7 +176,7 @@ END
         super
 
         opts.on('-t', '--style NAME',
-                'Output style. Can be nested (default), compact, or expanded.') do |name|
+                'Output style. Can be nested (default), compact, compressed, or expanded.') do |name|
           @options[:for_engine][:style] = name.to_sym
         end
       end
@@ -204,6 +210,35 @@ END
       def initialize(args)
         super
         @name = "Haml"
+        @options[:requires] = []
+        @options[:load_paths] = []
+      end
+
+      def set_opts(opts)
+        super
+
+        opts.on('-t', '--style NAME',
+                'Output style. Can be indented (default) or ugly.') do |name|
+          @options[:for_engine][:ugly] = true if name.to_sym == :ugly
+        end
+
+        opts.on('-f', '--format NAME',
+                'Output format. Can be xhtml (default), html4, or html5.') do |name|
+          @options[:for_engine][:format] = name.to_sym
+        end
+
+        opts.on('-e', '--escape-html',
+                '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
@@ -220,13 +255,16 @@ 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]
 
           case e
           when ::Haml::SyntaxError; raise "Syntax error on line #{get_line e}: #{e.message}"
-          when ::Haml::HamlError;   raise "Haml error on line #{get_line e}: #{e.message}"
+          when ::Haml::Error;       raise "Haml error on line #{get_line e}: #{e.message}"
           else raise "Exception on line #{get_line e}: #{e.message}\n  Use --trace for backtrace."
           end
         end
@@ -266,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
@@ -279,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
@@ -289,6 +334,8 @@ END
       def initialize(args)
         super
 
+        @module_opts = {}
+
         require 'sass/css'
       end
 
@@ -301,6 +348,10 @@ Description: Transforms a CSS file into corresponding Sass code.
 Options:
 END
 
+        opts.on('-a', '--alternate', 'Output using alternative Sass syntax (margin: 1px)') do
+          @module_opts[:alternate] = true
+        end
+
         super
       end
 
@@ -310,7 +361,7 @@ END
         input = @options[:input]
         output = @options[:output]
 
-        output.write(::Sass::CSS.new(input).render)
+        output.write(::Sass::CSS.new(input, @module_opts).render)
       end
     end
   end