haml 1.8.2 → 2.0.0

data/lib/haml/error.rb

@@ -1,13 +1,23 @@
 module Haml
-  # The abstract type of exception raised by Haml code.
-  class Error < StandardError; end
+  # An exception raised by Haml code.
+  class Error < Exception
+    # :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_offset is non-zero, it's added to that line number
+    # to get the line to report for the error.
+    attr_reader :line_offset
+
+    def initialize(message = nil, line_offset = 0)
+      super(message)
+      @line_offset = line_offset
+    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

@@ -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
 
@@ -145,6 +149,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 +175,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
@@ -206,6 +211,25 @@ END
         @name = "Haml"
       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
+      end
+
       def process_result
         super
         input = @options[:input]
@@ -226,7 +250,7 @@ END
 
           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
@@ -289,6 +313,8 @@ END
       def initialize(args)
         super
 
+        @module_opts = {}
+
         require 'sass/css'
       end
 
@@ -301,6 +327,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 +340,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

data/lib/haml/filters.rb

@@ -1,115 +1,260 @@
 # This file contains redefinitions of and wrappers around various text
 # filters so they can be used as Haml filters.
 
-# :stopdoc:
-
-require 'erb'
-require 'sass/engine'
-require 'stringio'
-
-begin
-  require 'rubygems'
-rescue LoadError; end
-
-class ERB; alias_method :render, :result; end
-
 module Haml
+  # The module containing the default filters,
+  # as well as the base module,
+  # Haml::Filters::Base.
   module Filters
-    class Plain
-      def initialize(text)
-        @text = text
-      end
+    # Returns a hash of defined filters.
+    def self.defined
+      @defined ||= {}
+    end
 
-      def render
-        @text
+    # The base module for Haml filters.
+    # User-defined filters should be modules including this module.
+    #
+    # A user-defined filter should override either Base#render or Base #compile.
+    # Base#render is the most common.
+    # It takes a string, the filter source,
+    # and returns another string,
+    # the result of the filter.
+    # For example:
+    #
+    #   module Haml::Filters::Sass
+    #     include Haml::Filters::Base
+    #
+    #     def render(text)
+    #       ::Sass::Engine.new(text).render
+    #     end
+    #   end
+    #
+    # For details on overriding #compile, see its documentation.
+    #
+    module Base
+      def self.included(base) # :nodoc:
+        Filters.defined[base.name.split("::").last.downcase] = base
+        base.extend(base)
       end
-    end
 
-    class Ruby
-      def initialize(text)
-        @text = text
+      # Takes a string, the source text that should be passed to the filter,
+      # and returns the string resulting from running the filter on <tt>text</tt>.
+      #
+      # This should be overridden in most individual filter modules
+      # to render text with the given filter.
+      # If compile is overridden, however, render doesn't need to be.
+      def render(text)
+        raise Error.new("#{self.inspect}#render not defined!")
       end
 
-      def render
-        old_stdout = $stdout
-        $stdout = StringIO.new
-        Object.new.instance_eval(@text)
-        old_stdout, $stdout = $stdout, old_stdout
-        old_stdout.pos = 0
-        old_stdout.read
+      def internal_compile(*args) # :nodoc:
+        resolve_lazy_requires
+        compile(*args)
       end
-    end
 
-    class Preserve
-      def initialize(text)
-        @text = text
+      # compile should be overridden when a filter needs to have access
+      # to the Haml evaluation context.
+      # Rather than applying a filter to a string at compile-time,
+      # compile uses the Haml::Precompiler instance to compile the string to Ruby code
+      # that will be executed in the context of the active Haml template.
+      #
+      # Warning: the Haml::Precompiler interface is neither well-documented
+      # nor guaranteed to be stable.
+      # If you want to make use of it,
+      # you'll probably need to look at the source code
+      # and should test your filter when upgrading to new Haml versions.
+      def compile(precompiler, text)
+        resolve_lazy_requires
+        filter = self
+        precompiler.instance_eval do
+          if contains_interpolation?(text)
+            return if options[:suppress_eval]
+
+            push_script(<<RUBY, false)
+find_and_preserve(#{filter.inspect}.render(#{unescape_interpolation(text)}))
+RUBY
+            return
+          end
+
+          rendered = Haml::Helpers::find_and_preserve(filter.render(text), precompiler.options[:preserve])
+
+          if !options[:ugly]
+            push_text(rendered.rstrip.gsub("\n", "\n#{'  ' * @output_tabs}"))
+          else
+            push_text(rendered.rstrip)
+          end
+        end
       end
 
-      def render
-        Haml::Helpers.preserve(@text)
+      # This becomes a class method of modules that include Base.
+      # It allows the module to specify one or more Ruby files
+      # that Haml should try to require when compiling the filter.
+      #
+      # The first file specified is tried first,
+      # then the second, etc.
+      # If none are found, the compilation throws an exception.
+      #
+      # For example:
+      #
+      #   module Haml::Filters::Markdown
+      #     lazy_require 'bluecloth', 'redcloth'
+      #
+      #     ...
+      #   end
+      #
+      def lazy_require(*reqs)
+        @lazy_requires = reqs
       end
-    end
 
-    class LazyLoaded
-      def initialize(*reqs)
-        reqs[0...-1].each do |req|
+      private
+
+      def resolve_lazy_requires
+        return unless @lazy_requires
+
+        @lazy_requires[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]
+          @required = @lazy_requires[-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")
+          if @lazy_requires.size == 1
+            raise Error.new("Can't run #{classname} filter; required file '#{@lazy_requires.first}' not found")
           else
-            raise HamlError.new("Can't run #{classname} filter; required #{reqs.map { |r| "'#{r}'" }.join(' or ')}, but none were found")
+            raise Error.new("Can't run #{classname} filter; required #{@lazy_requires.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
+end
+
+# :stopdoc:
+
+begin
+  require 'rubygems'
+rescue LoadError; end
+
+module Haml
+  module Filters
+    module Plain
+      include Base
+
+      def render(text); text; end
+    end
+
+    module Javascript
+      include Base
+
+      def render(text)
+        <<END
+<script type='text/javascript'>
+  //<![CDATA[
+    #{text.rstrip.gsub("\n", "\n    ")}
+  //]]>
+</script>
+END
+      end
+    end
+
+    module Cdata
+      include Base
+
+      def render(text)
+        "<![CDATA[#{("\n" + text).rstrip.gsub("\n", "\n    ")}\n]]>"
+      end
+    end
+
+    module Escaped
+      include Base
+
+      def render(text)
+        Haml::Helpers.html_escape text
+      end
+    end
+
+    module Ruby
+      include Base
+      lazy_require 'stringio'
+
+      def compile(precompiler, text)
+        return if precompiler.options[:suppress_eval]
+        precompiler.instance_eval do
+          push_silent <<-END.gsub("\n", ';')
+            _haml_old_stdout = $stdout
+            $stdout = StringIO.new(_hamlout.buffer, 'a')
+            #{text}
+            _haml_old_stdout, $stdout = $stdout, _haml_old_stdout
+            _haml_old_stdout.close
+          END
+        end
+      end
+    end
+
+    module Preserve
+      include Base
+
+      def render(text)
+        Haml::Helpers.preserve text
+      end
+    end
+
+    module Sass
+      include Base
+      lazy_require 'sass/engine'
+
+      def render(text)
+        ::Sass::Engine.new(text).render
+      end
+    end
+
+    module ERB
+      include Base
+      lazy_require 'erb'
+
+      def compile(precompiler, text)
+        return if precompiler.options[:suppress_eval]
+        src = ::ERB.new(text).src.sub(/^_erbout = '';/, "").gsub("\n", ';')
+        precompiler.send(:push_silent, src)
       end
+    end
+
+    module RedCloth
+      include Base
+      lazy_require 'redcloth'
 
-      def render
-        @engine.to_html
+      def render(text)
+        ::RedCloth.new(text).to_html
       end
     end
-      
+
     # Uses RedCloth to provide only Textile (not Markdown) parsing
-    class Textile < RedCloth
-      def render
-        @engine.to_html(:textile)
+    module Textile
+      include Base
+      lazy_require 'redcloth'
+
+      def render(text)
+        ::RedCloth.new(text).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')
+    module Markdown
+      include Base
+      lazy_require 'bluecloth', 'redcloth'
 
+      def render(text)
         if @required == 'bluecloth'
-          @engine = ::BlueCloth.new(text)
-        else
-          @engine = ::RedCloth.new(text)
-        end
-      end
-
-      def render
-        if @engine.is_a?(::BlueCloth)
-          @engine.to_html
+          ::BlueCloth.new(text).to_html
         else
-          @engine.to_html(:markdown)
+          ::RedCloth.new(text).to_html(:markdown)
         end
       end
     end