haml-edge 2.3.27 → 2.3.28

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-2.3.27
+2.3.28

data/VERSION

@@ -1 +1 @@
-2.3.27
+2.3.28

data/lib/haml/exec.rb

@@ -264,7 +264,7 @@ END
         output.close() if output.is_a? File
       rescue ::Sass::SyntaxError => e
         raise e if @options[:trace]
-        raise "Syntax error on line #{get_line e}: #{e.message}"
+        raise e.sass_backtrace_str("standard input")
       end
     end
 

data/lib/sass/engine.rb

@@ -1,6 +1,7 @@
 require 'strscan'
 require 'digest/sha1'
 require 'sass/tree/node'
+require 'sass/tree/root_node'
 require 'sass/tree/rule_node'
 require 'sass/tree/comment_node'
 require 'sass/tree/prop_node'
@@ -155,11 +156,14 @@ module Sass
     # @return [Sass::Tree::Node] The root of the parse tree.
     # @raise [Sass::SyntaxError] if there's an error in the document
     def to_tree
-      root = Tree::Node.new
+      root = Tree::RootNode.new(@template)
       append_children(root, tree(tabulate(@template)).first, true)
       root.options = @options
       root
-    rescue SyntaxError => e; e.add_metadata(@options[:filename], @line)
+    rescue SyntaxError => e
+      e.modify_backtrace(:filename => @options[:filename], :line => @line)
+      e.sass_template = @template
+      raise e
     end
 
     private
@@ -179,10 +183,11 @@ module Sass
         unless line_tab_str.empty?
           tab_str ||= line_tab_str
 
-          raise SyntaxError.new("Indenting at the beginning of the document is illegal.", index) if first
-          if tab_str.include?(?\s) && tab_str.include?(?\t)
-            raise SyntaxError.new("Indentation can't use both tabs and spaces.", index)
-          end
+          raise SyntaxError.new("Indenting at the beginning of the document is illegal.",
+            :line => index) if first
+
+          raise SyntaxError.new("Indentation can't use both tabs and spaces.",
+            :line => index) if tab_str.include?(?\s) && tab_str.include?(?\t)
         end
         first &&= !tab_str.nil?
         if tab_str.nil?
@@ -196,10 +201,14 @@ module Sass
         end
 
         line_tabs = line_tab_str.scan(tab_str).size
-        raise SyntaxError.new(<<END.strip.gsub("\n", ' '), index) if tab_str * line_tabs != line_tab_str
+        if tab_str * line_tabs != line_tab_str
+          message = <<END.strip.gsub("\n", ' ')
 Inconsistent indentation: #{Haml::Shared.human_indentation line_tab_str, true} used for indentation,
 but the rest of the document was indented using #{Haml::Shared.human_indentation tab_str}.
 END
+          raise SyntaxError.new(message, :line => index)
+        end
+
         lines << Line.new(line.strip, line_tabs, index, tab_str.size, @options[:filename], [])
       end
       lines
@@ -212,9 +221,8 @@ END
       nodes = []
       while (line = arr[i]) && line.tabs >= base
         if line.tabs > base
-          if line.tabs > base + 1
-            raise SyntaxError.new("The line was indented #{line.tabs - base} levels deeper than the previous line.", line.index)
-          end
+          raise SyntaxError.new("The line was indented #{line.tabs - base} levels deeper than the previous line.",
+            :line => line.index) if line.tabs > base + 1
 
           nodes.last.children, i = tree(arr, i)
         else
@@ -252,7 +260,8 @@ END
         child = build_tree(parent, line, root)
 
         if child.is_a?(Tree::RuleNode) && child.continued?
-          raise SyntaxError.new("Rules can't end in commas.", child.line) unless child.children.empty?
+          raise SyntaxError.new("Rules can't end in commas.",
+            :line => child.line) unless child.children.empty?
           if continued_rule
             continued_rule.add_rules child
           else
@@ -262,7 +271,8 @@ END
         end
 
         if continued_rule
-          raise SyntaxError.new("Rules can't end in commas.", continued_rule.line) unless child.is_a?(Tree::RuleNode)
+          raise SyntaxError.new("Rules can't end in commas.",
+            :line => continued_rule.line) unless child.is_a?(Tree::RuleNode)
           continued_rule.add_rules child
           continued_rule.children = child.children
           continued_rule, child = nil, continued_rule
@@ -272,7 +282,8 @@ END
         validate_and_append_child(parent, child, line, root)
       end
 
-      raise SyntaxError.new("Rules can't end in commas.", continued_rule.line) if continued_rule
+      raise SyntaxError.new("Rules can't end in commas.",
+        :line => continued_rule.line) if continued_rule
 
       parent
     end
@@ -281,9 +292,11 @@ END
       unless root
         case child
         when Tree::MixinDefNode
-          raise SyntaxError.new("Mixins may only be defined at the root of a document.", line.index)
+          raise SyntaxError.new("Mixins may only be defined at the root of a document.",
+            :line => line.index)
         when Tree::ImportNode
-          raise SyntaxError.new("Import directives may only be used at the root of a document.", line.index)
+          raise SyntaxError.new("Import directives may only be used at the root of a document.",
+            :line => line.index)
         end
       end
 
@@ -349,9 +362,9 @@ LONG
     def parse_property(line, property_regx)
       name, eq, value = line.text.scan(property_regx)[0]
 
-      if name.nil? || value.nil?
-        raise SyntaxError.new("Invalid property: \"#{line.text}\".", @line)
-      end
+      raise SyntaxError.new("Invalid property: \"#{line.text}\".",
+        :line => @line) if name.nil? || value.nil?
+
       expr = if (eq.strip[0] == SCRIPT_CHAR)
         parse_script(value, :offset => line.offset + line.text.index(value))
       else
@@ -362,8 +375,10 @@ LONG
 
     def parse_variable(line)
       name, op, value = line.text.scan(Script::MATCH)[0]
-      raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath variable declarations.", @line + 1) unless line.children.empty?
-      raise SyntaxError.new("Invalid variable: \"#{line.text}\".", @line) unless name && value
+      raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath variable declarations.",
+        :line => @line + 1) unless line.children.empty?
+      raise SyntaxError.new("Invalid variable: \"#{line.text}\".",
+        :line => @line) unless name && value
 
       Tree::VariableNode.new(name, parse_script(value, :offset => line.offset + line.text.index(value)), op == '||=')
     end
@@ -383,7 +398,8 @@ LONG
       # If value begins with url( or ",
       # it's a CSS @import rule and we don't want to touch it.
       if directive == "import" && value !~ /^(url\(|")/
-        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath import directives.", @line + 1) unless line.children.empty?
+        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath import directives.",
+          :line => @line + 1) unless line.children.empty?
         value.split(/,\s*/).map {|f| Tree::ImportNode.new(f)}
       elsif directive == "for"
         parse_for(line, root, value)
@@ -397,7 +413,8 @@ LONG
         Tree::IfNode.new(parse_script(value, :offset => offset))
       elsif directive == "debug"
         raise SyntaxError.new("Invalid debug directive '@debug': expected expression.") unless value
-        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath debug directives.", @line + 1) unless line.children.empty?
+        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath debug directives.",
+          :line => @line + 1) unless line.children.empty?
         offset = line.offset + line.text.index(value).to_i
         Tree::DebugNode.new(parse_script(value, :offset => offset))
       else
@@ -416,9 +433,9 @@ LONG
         else
           expected = "'to <expr>' or 'through <expr>'"
         end
-        raise SyntaxError.new("Invalid for directive '@for #{text}': expected #{expected}.", @line)
+        raise SyntaxError.new("Invalid for directive '@for #{text}': expected #{expected}.")
       end
-      raise SyntaxError.new("Invalid variable \"#{var}\".", @line) unless var =~ Script::VALIDATE
+      raise SyntaxError.new("Invalid variable \"#{var}\".") unless var =~ Script::VALIDATE
 
       parsed_from = parse_script(from_expr, :offset => line.offset + line.text.index(from_expr))
       parsed_to = parse_script(to_expr, :offset => line.offset + line.text.index(to_expr))
@@ -431,7 +448,7 @@ LONG
 
       if text
         if text !~ /^if\s+(.+)/
-          raise SyntaxError.new("Invalid else directive '@else #{text}': expected 'if <expr>'.", @line)
+          raise SyntaxError.new("Invalid else directive '@else #{text}': expected 'if <expr>'.")
         end
         expr = parse_script($1, :offset => line.offset + line.text.index($1))
       end
@@ -444,7 +461,7 @@ LONG
 
     def parse_mixin_definition(line)
       name, arg_string = line.text.scan(/^=\s*([^(]+)(.*)$/).first
-      raise SyntaxError.new("Invalid mixin \"#{line.text[1..-1]}\".", @line) if name.nil?
+      raise SyntaxError.new("Invalid mixin \"#{line.text[1..-1]}\".") if name.nil?
 
       offset = line.offset + line.text.size - arg_string.size
       args = Script::Parser.new(arg_string.strip, @line, offset).parse_mixin_definition_arglist
@@ -454,11 +471,12 @@ LONG
 
     def parse_mixin_include(line, root)
       name, arg_string = line.text.scan(/^\+\s*([^(]+)(.*)$/).first
-      raise SyntaxError.new("Invalid mixin include \"#{line.text}\".", @line) if name.nil?
+      raise SyntaxError.new("Invalid mixin include \"#{line.text}\".") if name.nil?
 
       offset = line.offset + line.text.size - arg_string.size
       args = Script::Parser.new(arg_string.strip, @line, offset).parse_mixin_include_arglist
-      raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath mixin directives.", @line + 1) unless line.children.empty?
+      raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath mixin directives.",
+        :line => @line + 1) unless line.children.empty?
       Tree::MixinNode.new(name, args)
     end
 

data/lib/sass/error.rb

@@ -4,51 +4,156 @@ module Sass
   # and the Sass file that was being parsed (if applicable).
   #
   # All Sass errors are raised as {Sass::SyntaxError}s.
+  #
+  # When dealing with SyntaxErrors,
+  # it's important to provide filename and line number information.
+  # This will be used in various error reports to users, including backtraces;
+  # see \{#sass\_backtrace} for details.
+  #
+  # Some of this information is usually provided as part of the constructor.
+  # New backtrace entries can be added with \{#add\_backtrace},
+  # which is called when an exception is raised between files (e.g. with `@import`).
+  #
+  # Often, a chunk of code will all have similar backtrace information -
+  # the same filename or even line.
+  # It may also be useful to have a default line number set.
+  # In those situations, the default values can be used
+  # by omitting the information on the original exception,
+  # and then calling \{#modify\_backtrace} in a wrapper `rescue`.
+  # When doing this, be sure that all exceptions ultimately end up
+  # with the information filled in.
   class SyntaxError < StandardError
-    # The line of the Sass template on which the error occurred.
+    # The backtrace of the error within Sass files.
+    # This is an array of hashes containing information for a single entry.
+    # The hashes have the following keys:
     #
-    # @return [Fixnum]
-    attr_accessor :sass_line
+    # `:filename`
+    # : The name of the file in which the exception was raised,
+    #   or `nil` if no filename is available.
+    #
+    # `:line`
+    # : The line of the file on which the error occurred. Never nil.
+    #
+    # This information is also included in standard backtrace format
+    # in the output of \{#backtrace}.
+    #
+    # @return [Aray<Hash<Symbol, Object>>]
+    attr_accessor :sass_backtrace
 
-    # The name of the file that was being parsed when the exception was raised.
-    # This could be `nil` if no filename is available.
+    # The text of the template where this error was raised.
     #
     # @return [String]
-    attr_reader :sass_filename
+    attr_accessor :sass_template
 
     # @param msg [String] The error message
-    # @param lineno [Fixnum] See \{#sass\_line}
-    def initialize(msg, lineno = nil)
+    # @param attrs [Hash<Symbol, Object>] The information in the backtrace entry.
+    #   See \{#sass\_backtrace}
+    def initialize(msg, attrs = {})
       @message = msg
-      @sass_line = lineno
+      @sass_backtrace = []
+      add_backtrace(attrs)
     end
 
-    # Add information about the filename and line on which the error was raised,
-    # and re-raises the exception.
+    # The name of the file in which the exception was raised.
+    # This could be `nil` if no filename is available.
     #
-    # @param filename [String] See \{#sass\_filename}
-    # @param line [Fixnum] See \{#sass\_line}
-    # @raise [Sass::SyntaxError] self
-    def add_metadata(filename, line)
-      self.sass_line ||= line
-      add_backtrace_entry(filename) unless sass_filename
-      raise self
+    # @return [String]
+    def sass_filename
+      sass_backtrace.first[:filename]
     end
 
-    # Adds a properly formatted entry to the exception's backtrace.
+    # The line of the Sass template on which the error occurred.
     #
-    # @param filename [String] The file in which the error occurred,
-    #   if applicable (defaults to "(sass)")
-    def add_backtrace_entry(filename) # :nodoc:
-      @sass_filename ||= filename
-      self.backtrace ||= []
-      self.backtrace.unshift "#{@sass_filename || '(sass)'}:#{@sass_line}"
+    # @return [Fixnum]
+    def sass_line
+      sass_backtrace.first[:line]
+    end
+
+    # Adds an entry to the exception's Sass backtrace.
+    #
+    # @param attrs [Hash<Symbol, Object>] The information in the backtrace entry.
+    #   See \{#sass\_backtrace}
+    def add_backtrace(attrs)
+      sass_backtrace << attrs.reject {|k, v| v.nil?}
+    end
+
+    # Modify the top Sass backtrace entry (that is, the last one)
+    # to have the given attributes.
+    # If that entry already has one of the given attributes set,
+    # that takes precendence.
+    #
+    # @param attrs [Hash<Symbol, Object>] The information to add to the backtrace entry.
+    #   See \{#sass\_backtrace}
+    def modify_backtrace(attrs)
+      sass_backtrace[-1] = attrs.reject {|k, v| v.nil?}.merge(sass_backtrace.last)
     end
 
     # @return [String] The error message
     def to_s
       @message
     end
+
+    # Returns the standard exception backtrace,
+    # including the Sass backtrace.
+    #
+    # @return [Array<String>]
+    def backtrace
+      return nil if super.nil?
+      sass_backtrace.map {|h| "#{h[:filename] || "(sass)"}:#{h[:line]}"} + super
+    end
+
+    # Returns a string representation of the Sass backtrace.
+    #
+    # @param default_filename [String] The filename to use for unknown files
+    # @see #sass_backtrace
+    # @return [String]
+    def sass_backtrace_str(default_filename = "an unknown file")
+      "Syntax error: #{message}" +
+        Haml::Util.enum_with_index(sass_backtrace).map do |entry, i|
+        "\n        #{i == 0 ? "on" : "from"} line #{entry[:line]}" +
+          " of #{entry[:filename] || default_filename}"
+      end.join
+    end
+
+    class << self
+      # Returns an error report for an exception in CSS format.
+      #
+      # @param e [Exception]
+      # @param full_exception [Boolean] The value of
+      #   \{file:SASS\_REFERENCE.md#full_exception-option `options[:full_exception]`}
+      def exception_to_css(e, options)
+        return "/* Internal stylesheet error */" unless options[:full_exception]
+
+        header = header_string(e, options)
+
+        <<END
+/*
+#{header}
+
+Backtrace:\n#{e.backtrace.join("\n")}
+*/
+body:before {
+  white-space: pre;
+  font-family: monospace;
+  content: "#{header.gsub('"', '\"').gsub("\n", '\\A ')}"; }
+END
+      end
+
+      private
+
+      def header_string(e, options)
+        return "#{e.class}: #{e.message}" unless e.is_a? Sass::SyntaxError
+
+        line_offset = options[:line] || 1
+        line_num = e.sass_line + 1 - line_offset
+        min = [line_num - 6, 0].max
+        section = e.sass_template.rstrip.split("\n")[min ... line_num + 5]
+        return e.sass_backtrace_str if section.nil? || section.empty?
+
+        e.sass_backtrace_str + "\n\n" + Haml::Util.enum_with_index(section).
+          map {|line, i| "#{line_offset + min + i}: #{line}"}.join("\n")
+      end
+    end
   end
 
   # The class for Sass errors that are raised due to invalid unit conversions

data/lib/sass/files.rb

@@ -13,7 +13,8 @@ module Sass
     # @param filename [String] The path to the Sass file
     # @param options [Hash<Symbol, Object>] The options hash.
     #   Only the {file:SASS_REFERENCE.md#cache-option `:cache_location`} option is used
-    # @raise [Sass::SyntaxError] if there's an error in the document
+    # @raise [Sass::SyntaxError] if there's an error in the document.
+    #   The caller has responsibility for setting backtrace information, if necessary
     def tree_for(filename, options)
       options = Sass::Engine::DEFAULT_OPTIONS.merge(options)
       text = File.read(filename)
@@ -30,15 +31,8 @@ module Sass
 
       engine = Sass::Engine.new(text, options.merge(:filename => filename))
 
-      begin
-        root = engine.to_tree
-      rescue Sass::SyntaxError => err
-        err.add_backtrace_entry(filename)
-        raise err
-      end
-
+      root = engine.to_tree
       try_to_write_sassc(root, compiled_filename, sha, options) if options[:cache]
-
       root
     end
 
@@ -77,7 +71,7 @@ module Sass
 
       return new_filename if new_filename
       return filename + '.css' unless was_sass
-      raise SyntaxError.new("File to import not found or unreadable: #{original_filename}.", @line)
+      raise SyntaxError.new("File to import not found or unreadable: #{original_filename}.")
     end
 
     private

data/lib/sass/plugin.rb

@@ -9,6 +9,7 @@ module Sass
   # when it's used as a plugin for various frameworks.
   # Currently Rails and Merb are supported out of the box.
   module Plugin
+    include Haml::Util
     extend self
 
     @options = {
@@ -82,7 +83,7 @@ module Sass
       result = begin
                  Sass::Files.tree_for(filename, engine_options(:css_filename => css, :filename => filename)).render
                rescue Exception => e
-                 exception_string(e)
+                 Sass::SyntaxError.exception_to_css(e, options)
                end
 
       # Create any directories that might be necessary
@@ -122,49 +123,6 @@ module Sass
       end
     end
 
-    def exception_string(e)
-      if options[:full_exception]
-        e_string = "#{e.class}: #{e.message}"
-
-        if e.is_a? Sass::SyntaxError
-          e_string << "\non line #{e.sass_line}"
-
-          if e.sass_filename
-            e_string << " of #{e.sass_filename}"
-
-            if File.exists?(e.sass_filename)
-              e_string << "\n\n"
-
-              min = [e.sass_line - 5, 0].max
-              begin
-                File.read(e.sass_filename).rstrip.split("\n")[
-                  min .. e.sass_line + 5
-                ].each_with_index do |line, i|
-                  e_string << "#{min + i + 1}: #{line}\n"
-                end
-              rescue
-                e_string << "Couldn't read sass file: #{e.sass_filename}"
-              end
-            end
-          end
-        end
-        <<END
-/*
-#{e_string}
-
-Backtrace:\n#{e.backtrace.join("\n")}
-*/
-body:before {
-  white-space: pre;
-  font-family: monospace;
-  content: "#{e_string.gsub('"', '\"').gsub("\n", '\\A ')}"; }
-END
-        # Fix an emacs syntax-highlighting hiccup: '
-      else
-        "/* Internal stylesheet error */"
-      end
-    end
-
     def template_filename(name, path)
       "#{path}/#{name}.sass"
     end

data/lib/sass/script/parser.rb

@@ -158,7 +158,7 @@ END
         if try_tok(:single_eq)
           val = assert_expr(:concat)
         elsif must_have_default
-          raise SyntaxError.new("Required argument #{var.inspect} must come before any optional arguments.", @line)
+          raise SyntaxError.new("Required argument #{var.inspect} must come before any optional arguments.")
         end
 
         return [[var, val]] unless try_tok(:comma)

data/lib/sass/script.rb

@@ -47,12 +47,8 @@ module Sass
     def self.parse(value, line, offset, filename = nil)
       Parser.parse(value, line, offset, filename)
     rescue Sass::SyntaxError => e
-      if e.message == "SassScript error"
-        e.instance_eval do
-          @message += ": #{value.dump}."
-        end
-      end
-      e.sass_line = line
+      e.message << ": #{value.inspect}." if e.message == "SassScript error"
+      e.modify_backtrace(:line => line, :filename => filename)
       raise e
     end
   end

data/lib/sass/tree/comment_node.rb

@@ -38,6 +38,16 @@ module Sass::Tree
       self.class == other.class && value == other.value && silent == other.silent && lines == other.lines
     end
 
+    # Returns `true` if this is a silent comment
+    # or the current style doesn't render comments.
+    #
+    # @return [Boolean]
+    def invisible?
+      style == :compressed || @silent
+    end
+
+    protected
+
     # Computes the CSS for the comment.
     #
     # Returns `nil` if this is a silent comment
@@ -47,7 +57,7 @@ module Sass::Tree
     # @param tabs [Fixnum] The level of indentation for the CSS
     # @return [String, nil] The resulting CSS
     # @see #invisible?
-    def to_s(tabs = 0, _ = nil)
+    def _to_s(tabs = 0, _ = nil)
       return if invisible?
       spaces = '  ' * (tabs - 1)
 
@@ -60,16 +70,6 @@ module Sass::Tree
       spaces + "/* " + content.join(style == :compact ? '' : "\n#{spaces} *") + " */"
     end
 
-    # Returns `true` if this is a silent comment
-    # or the current style doesn't render comments.
-    #
-    # @return [Boolean]
-    def invisible?
-      style == :compressed || @silent
-    end
-
-    protected
-
     # Removes this node from the tree if it's a silent comment.
     #
     # @param environment [Sass::Environment] The lexical environment containing

data/lib/sass/tree/directive_node.rb

@@ -20,11 +20,13 @@ module Sass::Tree
       super()
     end
 
+    protected
+
     # Computes the CSS for the directive.
     #
     # @param tabs [Fixnum] The level of indentation for the CSS
     # @return [String] The resulting CSS
-    def to_s(tabs)
+    def _to_s(tabs)
       if children.empty?
         value + ";"
       else

data/lib/sass/tree/import_node.rb

@@ -3,27 +3,28 @@ module Sass
     # A static node that wraps the {Sass::Tree} for an `@import`ed file.
     # It doesn't have a functional purpose other than to add the `@import`ed file
     # to the backtrace if an error occurs.
-    class ImportNode < Node
+    class ImportNode < RootNode
       # @param imported_filename [String] The name of the imported file
       def initialize(imported_filename)
         @imported_filename = imported_filename
-        super()
+        super(nil)
       end
 
+      def invisible?; to_s.empty?; end
+
+      protected
+
       # Computes the CSS for the imported file.
       #
       # @param args [Array] Ignored
-      def to_s(*args)
-        @to_s ||= (style == :compressed ? super().strip : super())
+      def _to_s(*args)
+        @to_s ||= (style == :compressed ? super.strip : super)
       rescue Sass::SyntaxError => e
-        e.add_backtrace_entry(@filename)
+        e.modify_backtrace(:filename => children.first.filename)
+        e.add_backtrace(:filename => @filename, :line => @line)
         raise e
       end
 
-      def invisible?; to_s.empty?; end
-
-      protected
-
       # Parses the imported file
       # and runs the dynamic Sass for it.
       #
@@ -31,10 +32,13 @@ module Sass
       #   variable and mixin values
       def perform!(environment)
         return unless full_filename = import
-        self.children = Sass::Files.tree_for(full_filename, @options).children
+        root = Sass::Files.tree_for(full_filename, @options)
+        @template = root.template
+        self.children = root.children
         self.children = perform_children(environment)
       rescue Sass::SyntaxError => e
-        e.add_backtrace_entry(@filename)
+        e.modify_backtrace(:filename => full_filename)
+        e.add_backtrace(:filename => @filename, :line => @line)
         raise e
       end
 
@@ -50,7 +54,7 @@ module Sass
         begin
           full_filename = Sass::Files.find_file_to_import(@imported_filename, import_paths)
         rescue Exception => e
-          raise SyntaxError.new(e.message, self.line)
+          raise SyntaxError.new(e.message, :line => self.line, :filename => @filename)
         end
 
         if full_filename =~ /\.css$/

data/lib/sass/tree/mixin_node.rb

@@ -24,7 +24,7 @@ module Sass::Tree
     # @raise [Sass::SyntaxError] if an incorrect number of arguments was passed
     # @see Sass::Tree
     def _perform(environment)
-      raise Sass::SyntaxError.new("Undefined mixin '#{@name}'.", @line) unless mixin = environment.mixin(@name)
+      raise Sass::SyntaxError.new("Undefined mixin '#{@name}'.") unless mixin = environment.mixin(@name)
 
       raise Sass::SyntaxError.new(<<END.gsub("\n", "")) if mixin.args.size < @args.size
 Mixin #{@name} takes #{mixin.args.size} argument#{'s' if mixin.args.size != 1}

data/lib/sass/tree/node.rb

@@ -15,8 +15,7 @@ module Sass
   # Nodes that only appear in the pre-perform state are called **dynamic nodes**;
   # those that appear in both states are called **static nodes**.
   module Tree
-    # This class doubles as the root node of the parse tree
-    # and the superclass of all other parse-tree nodes.
+    # The abstract superclass of all parse-tree nodes.
     class Node
       # The child nodes of this node.
       #
@@ -66,7 +65,7 @@ module Sass
       # @see #invalid_child?
       def <<(child)
         if msg = invalid_child?(child)
-          raise Sass::SyntaxError.new(msg, child.line)
+          raise Sass::SyntaxError.new(msg, :line => child.line)
         end
         @children << child
       end
@@ -110,30 +109,28 @@ module Sass
       # @return [Boolean]
       def invisible?; false; end
 
+      # The output style. See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      #
+      # @return [Symbol]
+      def style
+        @options[:style]
+      end
+
       # Computes the CSS corresponding to this Sass tree.
       #
       # Only static-node subclasses need to implement \{#to\_s}.
       #
       # This may return `nil`, but it will only do so if \{#invisible?} is true.
       #
+      # @param args [Array] Passed on to \{#\_to\_s}
       # @return [String, nil] The resulting CSS
       # @raise [Sass::SyntaxError] if some element of the tree is invalid
       # @see Sass::Tree
-      def to_s
-        result = String.new
-        children.each do |child|
-          if child.is_a? PropNode
-            raise Sass::SyntaxError.new('Properties aren\'t allowed at the root of a document.', child.line)
-          else
-            next if child.invisible?
-            child_str = child.to_s(1)
-            result << child_str + (style == :compressed ? '' : "\n")
-          end
-        end
-        result.rstrip!
-        return "" if result.empty?
-        return result + "\n"
-      rescue Sass::SyntaxError => e; e.add_metadata(filename, line)
+      def to_s(*args)
+        _to_s(*args)
+      rescue Sass::SyntaxError => e
+        e.modify_backtrace(:filename => filename, :line => line)
+        raise e
       end
 
       # Runs the dynamic Sass code:
@@ -154,18 +151,24 @@ module Sass
       def perform(environment)
         environment.options = @options if self.class == Tree::Node
         _perform(environment)
-      rescue Sass::SyntaxError => e; e.add_metadata(filename, line)
+      rescue Sass::SyntaxError => e
+        e.modify_backtrace(:filename => filename, :line => line)
+        raise e
       end
 
-      # The output style. See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      protected
+
+      # Computes the CSS corresponding to this particular Sass node.
       #
-      # @return [Symbol]
-      def style
-        @options[:style]
+      # @param args [Array] ignored
+      # @return [String, nil] The resulting CSS
+      # @raise [Sass::SyntaxError] if some element of the tree is invalid
+      # @see #to_s
+      # @see Sass::Tree
+      def _to_s
+        raise NotImplementedError.new("All static-node subclasses of Sass::Tree::Node must override #_to_s or #to_s.")
       end
 
-      protected
-
       # Runs any dynamic Sass code in this particular node.
       # This doesn't modify this node or any of its children.
       #
@@ -228,7 +231,7 @@ module Sass
       def balance(*args)
         res = Haml::Shared.balance(*args)
         return res if res
-        raise Sass::SyntaxError.new("Unbalanced brackets.", line)
+        raise Sass::SyntaxError.new("Unbalanced brackets.", :line => line)
       end
 
       # Returns an error message if the given child node is invalid,

data/lib/sass/tree/prop_node.rb

@@ -34,29 +34,28 @@ module Sass::Tree
       self.class == other.class && name == other.name && value == other.value && super
     end
 
+    protected
+
     # Computes the CSS for the property.
     #
     # @param tabs [Fixnum] The level of indentation for the CSS
     # @param parent_name [String] The name of the parent property (e.g. `text`) or nil
     # @return [String] The resulting CSS
     # @raise [Sass::SyntaxError] if the property uses invalid syntax
-    def to_s(tabs, parent_name = nil)
+    def _to_s(tabs, parent_name = nil)
       if @options[:property_syntax] == :old && @prop_syntax == :new
         raise Sass::SyntaxError.new("Illegal property syntax: can't use new syntax when :property_syntax => :old is set.")
       elsif @options[:property_syntax] == :new && @prop_syntax == :old
         raise Sass::SyntaxError.new("Illegal property syntax: can't use old syntax when :property_syntax => :new is set.")
+      elsif value[-1] == ?;
+        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no \";\" required at end-of-line).")
+      elsif value.empty? && children.empty?
+        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no value).")
       end
 
-      if value[-1] == ?;
-        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no \";\" required at end-of-line).", @line)
-      end
       real_name = name
       real_name = "#{parent_name}-#{real_name}" if parent_name
-      
-      if value.empty? && children.empty?
-        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no value).", @line)
-      end
-      
+
       join_string = case style
                     when :compact; ' '
                     when :compressed; ''
@@ -76,8 +75,6 @@ module Sass::Tree
       (style == :compressed && parent_name) ? to_return : to_return[0...-1]
     end
 
-    protected
-
     # Runs any SassScript that may be embedded in the property.
     #
     # @param environment [Sass::Environment] The lexical environment containing

data/lib/sass/tree/root_node.rb

@@ -0,0 +1,56 @@
+module Sass
+  module Tree
+    # A static node that is the root node of the Sass document.
+    class RootNode < Node
+      # The Sass template from which this node was created
+      #
+      # @param template [String]
+      attr_reader :template
+
+      # @param template [String] The Sass template from which this node was created
+      def initialize(template)
+        super()
+        @template = template
+      end
+
+      # @see \{Node#to\_s}
+      def to_s(*args)
+        super
+      rescue Sass::SyntaxError => e
+        e.sass_template = @template
+        raise e
+      end
+
+      # @see \{Node#perform}
+      def perform(*args)
+        super
+      rescue Sass::SyntaxError => e
+        e.sass_template = @template
+        raise e
+      end
+
+      protected
+
+      # Computes the CSS corresponding to this Sass tree.
+      #
+      # @param args [Array] ignored
+      # @return [String] The resulting CSS
+      # @raise [Sass::SyntaxError] if some element of the tree is invalid
+      # @see Sass::Tree
+      def _to_s(*args)
+        result = String.new
+        children.each do |child|
+          raise Sass::SyntaxError.new('Properties aren\'t allowed at the root of a document.',
+            :line => child.line) if child.is_a? PropNode
+
+          next if child.invisible?
+          child_str = child.to_s(1)
+          result << child_str + (style == :compressed ? '' : "\n")
+        end
+        result.rstrip!
+        return "" if result.empty?
+        return result + "\n"
+      end
+    end
+  end
+end

data/lib/sass/tree/rule_node.rb

@@ -69,6 +69,8 @@ module Sass::Tree
       @rules.last[-1] == ?,
     end
 
+    protected
+
     # Computes the CSS for the rule.
     #
     # @param tabs [Fixnum] The level of indentation for the CSS
@@ -76,7 +78,7 @@ module Sass::Tree
     #   (see \{#rules}), or `nil` if there are no parents
     # @return [String] The resulting CSS
     # @raise [Sass::SyntaxError] if the rule has no parents but uses `&`
-    def to_s(tabs, super_rules = nil)
+    def _to_s(tabs, super_rules = nil)
       resolved_rules = resolve_parent_refs(super_rules)
 
       properties = []
@@ -144,8 +146,6 @@ module Sass::Tree
       to_return
     end
 
-    protected
-
     # Runs any SassScript that may be embedded in the rule,
     # and parses the selectors for commas.
     #
@@ -163,7 +163,7 @@ module Sass::Tree
         return @parsed_rules.map do |line|
           line.map do |rule|
             if rule.include?(:parent)
-              raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.", self.line)
+              raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.")
             end
 
             rule.join

data/test/sass/engine_test.rb

@@ -180,18 +180,78 @@ SASS
   end
 
   def test_imported_exception
-    [nil, 2].each do |i|
+    [1, 2, 3].each do |i|
       begin
         Sass::Engine.new("@import bork#{i}", :load_paths => [File.dirname(__FILE__) + '/templates/']).render
       rescue Sass::SyntaxError => err
         assert_equal(2, err.sass_line)
-        assert_match(/bork#{i}\.sass$/, err.sass_filename)
+        assert_match(/(\/|^)bork#{i}\.sass$/, err.sass_filename)
+
+        assert_equal(err.sass_filename, err.sass_backtrace.first[:filename])
+        assert_equal(err.sass_line, err.sass_backtrace.first[:line])
+
+        assert_nil(err.sass_backtrace[1][:filename])
+        assert_equal(1, err.sass_backtrace[1][:line])
+
+        assert_match(/(\/|^)bork#{i}\.sass:2$/, err.backtrace.first)
+        assert_equal("(sass):1", err.backtrace[1])
+      else
+        assert(false, "Exception not raised for imported template: bork#{i}")
+      end
+    end
+  end
+
+  def test_double_imported_exception
+    [1, 2, 3].each do |i|
+      begin
+        Sass::Engine.new("@import nested_bork#{i}", :load_paths => [File.dirname(__FILE__) + '/templates/']).render
+      rescue Sass::SyntaxError => err
+        assert_equal(2, err.sass_line)
+        assert_match(/(\/|^)bork#{i}\.sass$/, err.sass_filename)
+
+        assert_equal(err.sass_filename, err.sass_backtrace.first[:filename])
+        assert_equal(err.sass_line, err.sass_backtrace.first[:line])
+
+        assert_match(/(\/|^)nested_bork#{i}\.sass$/, err.sass_backtrace[1][:filename])
+        assert_equal(2, err.sass_backtrace[1][:line])
+
+        assert_nil(err.sass_backtrace[2][:filename])
+        assert_equal(1, err.sass_backtrace[2][:line])
+
+        assert_match(/(\/|^)bork#{i}\.sass:2$/, err.backtrace.first)
+        assert_match(/(\/|^)nested_bork#{i}\.sass:2$/, err.backtrace[1])
+        assert_equal("(sass):1", err.backtrace[2])
       else
         assert(false, "Exception not raised for imported template: bork#{i}")
       end
     end
   end
 
+  def test_exception_css_with_offset
+    opts = {:full_exception => true, :line => 362}
+    render(("a\n  b: c\n" * 10) + "d\n  e:\n" + ("f\n  g: h\n" * 10), opts)
+  rescue Sass::SyntaxError => e
+    assert_equal(<<CSS, Sass::SyntaxError.exception_to_css(e, opts).split("\n")[0..15].join("\n"))
+/*
+Syntax error: Invalid property: "e: " (no value).
+        on line 383 of test_exception_css_with_offset_inline.sass
+
+378: a
+379:   b: c
+380: a
+381:   b: c
+382: d
+383:   e:
+384: f
+385:   g: h
+386: f
+387:   g: h
+388: f
+CSS
+  else
+    assert(false, "Exception not raised for test_exception_css_with_offset")
+  end
+
   def test_css_import
     assert_equal("@import url(./fonts.css) screen;\n", render("@import url(./fonts.css) screen"))
     assert_equal("@import \"./fonts.css\" screen;\n", render("@import \"./fonts.css\" screen"))
@@ -255,12 +315,14 @@ SASS
     rescue Sass::SyntaxError => e
       assert_equal("Illegal property syntax: can't use new syntax when :property_syntax => :old is set.",
                    e.message)
+      assert_equal(2, e.sass_line)
     else
       assert(false, "SyntaxError not raised for :property_syntax => :old")
     end
 
     begin
       render("a\n  :b c", :property_syntax => :new)
+      assert_equal(2, e.sass_line)
     rescue Sass::SyntaxError => e
       assert_equal("Illegal property syntax: can't use old syntax when :property_syntax => :new is set.",
                    e.message)

data/test/sass/plugin_test.rb

@@ -52,21 +52,28 @@ class SassPluginTest < Test::Unit::TestCase
   end
 
   def test_full_exception_handling
-    File.delete(tempfile_loc('bork'))
+    File.delete(tempfile_loc('bork1'))
     Sass::Plugin.update_stylesheets
-    File.open(tempfile_loc('bork')) do |file|
-      assert_equal("/*\nSass::SyntaxError: Undefined variable: \"!bork\".\non line 2 of #{template_loc('bork')}\n\n1: bork\n2:   :bork= !bork", file.read.split("\n")[0...6].join("\n"))
+    File.open(tempfile_loc('bork1')) do |file|
+      assert_equal(<<CSS.strip, file.read.split("\n")[0...6].join("\n"))
+/*
+Syntax error: Undefined variable: "!bork".
+        on line 2 of #{template_loc('bork1')}
+
+1: bork
+2:   :bork= !bork
+CSS
     end
-    File.delete(tempfile_loc('bork'))
+    File.delete(tempfile_loc('bork1'))
   end
 
   def test_nonfull_exception_handling
     Sass::Plugin.options[:full_exception] = false
 
-    File.delete(tempfile_loc('bork'))
+    File.delete(tempfile_loc('bork1'))
     Sass::Plugin.update_stylesheets
-    assert_equal("/* Internal stylesheet error */", File.read(tempfile_loc('bork')))
-    File.delete(tempfile_loc('bork'))
+    assert_equal("/* Internal stylesheet error */", File.read(tempfile_loc('bork1')))
+    File.delete(tempfile_loc('bork1'))
 
     Sass::Plugin.options[:full_exception] = true
   end

data/test/sass/templates/bork3.sass

@@ -0,0 +1,2 @@
+bork
+  bork:

data/test/sass/templates/nested_bork1.sass

@@ -0,0 +1,2 @@
+
+@import bork1

data/test/sass/templates/nested_bork2.sass

@@ -0,0 +1,2 @@
+
+@import bork2

data/test/sass/templates/nested_bork3.sass

@@ -0,0 +1,2 @@
+
+@import bork3

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: haml-edge
 version: !ruby/object:Gem::Version 
-  version: 2.3.27
+  version: 2.3.28
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-28 00:00:00 -04:00
+date: 2009-09-14 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -110,6 +110,7 @@ files:
 - lib/sass/tree/node.rb
 - lib/sass/tree/prop_node.rb
 - lib/sass/tree/rule_node.rb
+- lib/sass/tree/root_node.rb
 - lib/sass/tree/variable_node.rb
 - lib/sass/tree/while_node.rb
 - bin/css2sass
@@ -221,8 +222,9 @@ files:
 - test/sass/templates/_partial.sass
 - test/sass/templates/alt.sass
 - test/sass/templates/basic.sass
-- test/sass/templates/bork.sass
+- test/sass/templates/bork1.sass
 - test/sass/templates/bork2.sass
+- test/sass/templates/bork3.sass
 - test/sass/templates/compact.sass
 - test/sass/templates/complex.sass
 - test/sass/templates/compressed.sass
@@ -233,6 +235,9 @@ files:
 - test/sass/templates/mixins.sass
 - test/sass/templates/multiline.sass
 - test/sass/templates/nested.sass
+- test/sass/templates/nested_bork1.sass
+- test/sass/templates/nested_bork2.sass
+- test/sass/templates/nested_bork3.sass
 - test/sass/templates/parent_ref.sass
 - test/sass/templates/script.sass
 - test/sass/templates/subdir