haml 1.7.2 → 1.8.0

data/lib/haml/error.rb

@@ -1,43 +1,13 @@
 module Haml
   # The abstract type of exception raised by Haml code.
-  # Haml::SyntaxError includes this module,
-  # as do all exceptions raised by Ruby code within Haml.
-  #
-  # Haml::Error encapsulates information about the exception,
-  # such as the line of the Haml template it was raised on
-  # and the Haml file that was being parsed (if applicable).
-  # It also provides a handy way to rescue only exceptions raised
-  # because of a faulty template.
-  module Error
-    # The line of the Haml template on which the exception was thrown.
-    attr_reader :haml_line
-
-    # The name of the file that was being parsed when the exception was raised.
-    # This will be nil unless Haml is being used as an ActionView plugin.
-    attr_reader :haml_filename
-
-    # Adds a properly formatted entry to the exception's backtrace.
-    # +lineno+ should be the line on which the error occurred.
-    # +filename+ should be the file in which the error occurred,
-    # if applicable (defaults to "(haml)").
-    def add_backtrace_entry(lineno, filename = nil) # :nodoc:
-      @haml_line = lineno
-      @haml_filename = filename
-      self.backtrace ||= []
-      self.backtrace.unshift "#{filename || '(haml)'}:#{lineno}"
-    end
-  end
+  class Error < StandardError; 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 < StandardError
-    include Haml::Error
-  end
+  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 < StandardError
-    include Haml::Error
-  end
+  class HamlError < Haml::Error; end
 end

data/lib/haml/exec.rb

@@ -17,7 +17,7 @@ module Haml
 
       def parse!
         begin
-          @opts = OptionParser.new(&(method(:set_opts).to_proc))
+          @opts = OptionParser.new(&method(:set_opts))
           @opts.parse!(@args)
 
           process_result
@@ -26,14 +26,10 @@ module Haml
         rescue Exception => e
           raise e if e.is_a? SystemExit
 
-          line = e.backtrace[0].scan(/:(.*)/)[0]
-          puts "#{e.class} on line #{line}: #{e.message}"
+          $stderr.print "#{e.class} on line #{get_line e}: " if @options[:trace]
+          $stderr.puts e.message
 
-          if @options[:trace]
-            e.backtrace[1..-1].each { |t| puts "  #{t}" }
-          else
-            puts "  Use --trace to see traceback"
-          end
+          e.backtrace[1..-1].each { |t| $stderr.puts "  #{t}" } if @options[:trace]
 
           exit 1
         end
@@ -43,23 +39,20 @@ module Haml
       def to_s
         @opts.to_s
       end
+
+      protected
+
+      def get_line(exception)
+        exception.backtrace[0].scan(/:(\d+)/)[0]
+      end
       
       private
 
       def set_opts(opts)
-        opts.on('--stdin', :NONE, 'Read input from standard input instead of an input file') do
+        opts.on('-s', '--stdin', :NONE, 'Read input from standard input instead of an input file') do
           @options[:input] = $stdin
         end
 
-        opts.on('--stdout', :NONE, 'Print output to standard output instead of an output file') do
-          @options[:output] = $stdout
-        end
-
-        opts.on('-s', '--stdio', 'Read input from standard input and print output to standard output') do
-          @options[:input] = $stdin
-          @options[:output] = $stdout
-        end
-
         opts.on('--trace', :NONE, 'Show a full traceback on error') do
           @options[:trace] = true
         end
@@ -76,49 +69,40 @@ module Haml
       end
 
       def process_result
-        input = @options[:input]
-        output = @options[:output]
-
-        if input
-          output ||= ARGV[0]
-        else
-          input ||= ARGV[0]
-          output ||= ARGV[1]
-        end
-
-        unless input && output
-          puts @opts
-          exit 1
-        end
-
-        if input.is_a?(String) && !File.exists?(input)
-          puts "File #{input} doesn't exist!"
-          exit 1
-        end
-
-        unless input.is_a? IO
-          input = File.open(input)
-          input_file = true
-        end
-
-        unless output.is_a? IO
-          output = File.open(output, "w")
-          output_file = true
-        end
+        input, output = @options[:input], @options[:output]
+        input_file, output_file = if input
+                                    [nil, open_file(ARGV[0], 'w')]
+                                  else
+                                    [open_file(ARGV[0]), open_file(ARGV[1], 'w')]
+                                  end
+
+        input  ||= input_file
+        output ||= output_file
+        input  ||= $stdin
+        output ||= $stdout
+
+        @options[:input], @options[:output] = input, output
+      end
 
-        @options[:input] = input
-        @options[:output] = output
+      def open_file(filename, flag = 'r')
+        return if filename.nil?
+        File.open(filename, flag)
       end
     end
 
     # A class encapsulating the executable functionality
     # specific to Haml and Sass.
     class HamlSass < Generic # :nodoc:
+      def initialize(args)
+        super
+        @options[:for_engine] = {}
+      end
+
       private
 
       def set_opts(opts)
         opts.banner = <<END
-Usage: #{@name.downcase} [options] (#{@name.downcase} file) (output file)
+Usage: #{@name.downcase} [options] [INPUT] [OUTPUT]
 
 Description:
   Uses the #{@name} engine to parse the specified template
@@ -127,7 +111,7 @@ Description:
 Options:
 END
        
-        opts.on('--rails RAILS_DIR', "Install Haml from the Gem to a Rails project") do |dir|
+        opts.on('--rails RAILS_DIR', "Install Haml and Sass from the Gem to a Rails project") do |dir|
           original_dir = dir
 
           dir = File.join(dir, 'vendor', 'plugins')
@@ -152,22 +136,19 @@ END
           end
 
           File.open(File.join(dir, 'init.rb'), 'w') do |file|
-            file.puts <<END
-require 'rubygems'
-require 'haml'
-require 'haml/template'
-require 'sass'
-require 'sass/plugin'
-
-ActionView::Base.register_template_handler('haml', Haml::Template)
-Sass::Plugin.update_stylesheets
-END
+            file.puts "require 'rubygems'"
+            file << File.read(File.dirname(__FILE__) + "/../../init.rb")
           end
 
           puts "Haml plugin added to #{original_dir}"
           exit
         end
 
+        opts.on('-c', '--check', "Just check syntax, don't evaluate.") do
+          @options[:check_syntax] = true
+          @options[:output] = StringIO.new
+        end
+
         super
       end
 
@@ -185,6 +166,15 @@ END
         @name = "Sass"
       end
 
+      def set_opts(opts)
+        super
+
+        opts.on('-t', '--style NAME',
+                'Output style. Can be nested (default), compact, or expanded.') do |name|
+          @options[:for_engine][:style] = name.to_sym
+        end
+      end
+
       def process_result
         super
         input = @options[:input]
@@ -192,7 +182,17 @@ END
 
         template = input.read()
         input.close() if input.is_a? File
-        result = ::Sass::Engine.new(template).render
+
+        begin
+          # We don't need to do any special handling of @options[:check_syntax] here,
+          # because the Sass syntax checking happens alongside evaluation
+          # and evaluation doesn't actually evaluate any code anyway.
+          result = ::Sass::Engine.new(template, @options[:for_engine]).render
+        rescue ::Sass::SyntaxError => e
+          raise e if @options[:trace]
+          raise "Syntax error on line #{get_line e}: #{e.message}"
+        end
+
         output.write(result)
         output.close() if output.is_a? File
       end
@@ -213,7 +213,24 @@ END
 
         template = input.read()
         input.close() if input.is_a? File
-        result = ::Haml::Engine.new(template).to_html
+
+        begin
+          engine = ::Haml::Engine.new(template, @options[:for_engine])
+          if @options[:check_syntax]
+            puts "Syntax OK"
+            return
+          end
+          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}"
+          else raise "Exception on line #{get_line e}: #{e.message}\n  Use --trace for backtrace."
+          end
+        end
+
         output.write(result)
         output.close() if output.is_a? File
       end
@@ -238,7 +255,7 @@ END
 
       def set_opts(opts)
         opts.banner = <<END
-Usage: html2haml [options] (html file) (output file)
+Usage: html2haml [options] [INPUT] [OUTPUT]
 
 Description: Transforms an HTML file into corresponding Haml code.
 
@@ -249,6 +266,10 @@ END
           @module_opts[:rhtml] = true
         end
 
+        opts.on('-x', '--xhtml', 'Parse the input using the more strict XHTML parser.') do
+          @module_opts[:xhtml] = true
+        end
+
         super
       end
 
@@ -273,7 +294,7 @@ END
 
       def set_opts(opts)
         opts.banner = <<END
-Usage: css2sass [options] (css file) (output file)
+Usage: css2sass [options] [INPUT] [OUTPUT]
 
 Description: Transforms a CSS file into corresponding Sass code.
 

data/lib/haml/filters.rb

@@ -7,22 +7,12 @@ require 'erb'
 require 'sass/engine'
 require 'stringio'
 
-volatile_requires = ['rubygems', 'redcloth', 'bluecloth']
-NOT_LOADED = [] unless defined?(NOT_LOADED)
-volatile_requires.each do |file|
-  begin
-    require file
-  rescue LoadError
-    NOT_LOADED.push file
-  end
-end
+begin
+  require 'rubygems'
+rescue LoadError; end
 
 class ERB; alias_method :render, :result; end
 
-unless NOT_LOADED.include? 'bluecloth'
-  class BlueCloth; alias_method :render, :to_html; end
-end
-
 module Haml
   module Filters
     class Plain
@@ -60,26 +50,66 @@ module Haml
       end
     end
 
-    unless NOT_LOADED.include? 'bluecloth'
-      Markdown = BlueCloth unless defined?(Markdown)
+    class LazyLoaded
+      def initialize(*reqs)
+        reqs[0...-1].each do |req|
+          begin
+            @required = req
+            require @required
+            return
+          rescue LoadError; end # RCov doesn't see this, but it is run
+        end
+       
+        begin
+          @required = reqs[-1]
+          require @required
+        rescue LoadError => e
+          classname = self.class.to_s.gsub(/\w+::/, '')
+
+          if reqs.size == 1
+            raise HamlError.new("Can't run #{classname} filter; required file '#{reqs.first}' not found")
+          else
+            raise HamlError.new("Can't run #{classname} filter; required #{reqs.map { |r| "'#{r}'" }.join(' or ')}, but none were found")
+          end
+        end
+      end
     end
+    
+    class RedCloth < LazyLoaded
+      def initialize(text)
+        super('redcloth')
+        @engine = ::RedCloth.new(text)
+      end
 
-    unless NOT_LOADED.include? 'redcloth'
-      class ::RedCloth; alias_method :render, :to_html; end
+      def render
+        @engine.to_html
+      end
+    end
       
-      # Uses RedCloth to provide only Textile (not Markdown) parsing
-      class Textile < RedCloth
-        def render
-          self.to_html(:textile)
+    # Uses RedCloth to provide only Textile (not Markdown) parsing
+    class Textile < RedCloth
+      def render
+        @engine.to_html(:textile)
+      end
+    end
+
+    # Uses BlueCloth or RedCloth to provide only Markdown (not Textile) parsing
+    class Markdown < LazyLoaded
+      def initialize(text)
+        super('bluecloth', 'redcloth')
+
+        if @required == 'bluecloth'
+          @engine = ::BlueCloth.new(text)
+        else
+          @engine = ::RedCloth.new(text)
         end
       end
 
-      unless defined?(Markdown)
-        # Uses RedCloth to provide only Markdown (not Textile) parsing
-        class Markdown < RedCloth
-          def render
-            self.to_html(:markdown)
-          end
+      def render
+        if @engine.is_a?(::BlueCloth)
+          @engine.to_html
+        else
+          @engine.to_html(:markdown)
         end
       end
     end

data/lib/haml/helpers.rb

@@ -17,20 +17,56 @@ module Haml
       @@action_view_defined
     end
 
+    # Note: this does *not* need to be called
+    # when using Haml helpers normally
+    # in Rails.
+    #
+    # Initializes the current object
+    # as though it were in the same context
+    # as a normal ActionView rendering
+    # using Haml.
+    # This is useful if you want to use the helpers in a context
+    # other than the normal setup with ActionView.
+    # For example:
+    #
+    #   context = Object.new
+    #   class << context
+    #     include Haml::Helpers
+    #   end
+    #   context.init_haml_helpers
+    #   context.open :p, "Stuff"
+    # 
+    def init_haml_helpers
+      @haml_is_haml = true
+      @haml_stack = [Haml::Buffer.new]
+      nil
+    end
+
+    # call-seq:
+    #   find_and_preserve(input)
+    #   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)
+    def find_and_preserve(input = '', &block)
+      return find_and_preserve(capture_haml(&block)) if block
+
       input = input.to_s
-      input.scan(/<(textarea|code|pre)[^>]*>(.*?)<\/\1>/im) do |tag, contents|
-        input = input.gsub(contents, preserve(contents))
+      input.gsub(/<(textarea|code|pre)([^>]*)>(.*?)(<\/\1>)/im) do
+        "<#{$1}#{$2}>#{preserve($3)}</#{$1}>"
       end
-      input
     end
 
+    # call-seq:
+    #   preserve(input)
+    #   preserve {...}
+    #
     # Takes any string, finds all the endlines and converts them to
     # HTML entities for endlines so they'll render correctly in
     # whitespace-sensitive tags without screwing up the indentation.
-    def preserve(input)      
+    def preserve(input = '', &block)
+      return preserve(capture_haml(&block)) if block
+
       input.gsub(/\n/, '&#x000A;').gsub(/\r/, '')
     end
 
@@ -256,15 +292,22 @@ module Haml
         attributes = alt_atts
       end
 
-      puts "<#{name}#{buffer.build_attributes(attributes)}>"
-      tab_up
+      if text.nil? && block.nil?
+        puts "<#{name}#{Haml::Precompiler.build_attributes(buffer.options[:attr_wrapper], attributes)} />"
+        return nil
+      end
+
+      puts "<#{name}#{Haml::Precompiler.build_attributes(buffer.options[:attr_wrapper], 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
+        tab_down
+      end
       puts "</#{name}>"
       nil
     end
@@ -314,7 +357,7 @@ module Haml
     def is_haml?
       @haml_is_haml
     end
-    
+
     include ActionViewExtensions if self.const_defined? "ActionViewExtensions"
   end
 end