radiantcms-couchrest_model 0.1.3 → 0.1.4

data/vendor/plugins/haml/lib/haml/version.rb

@@ -23,27 +23,11 @@ module Haml
     #       :major  => 2, :minor => 1, :teeny => 0
     #     }
     #
-    # If a prerelease version of Haml is being used,
-    # the `:string` and `:number` fields will reflect the full version
-    # (e.g. `"2.2.beta.1"`), and the `:teeny` field will be `-1`.
-    # A `:prerelease` key will contain the name of the prerelease (e.g. `"beta"`),
-    # and a `:prerelease_number` key will contain the rerelease number.
-    # For example:
-    #
-    #     {
-    #       :string => "3.0.beta.1",
-    #       :number => "3.0.beta.1",
-    #       :major => 3, :minor => 0, :teeny => -1,
-    #       :prerelease => "beta",
-    #       :prerelease_number => 1
-    #     }
-    #
     # @return [{Symbol => String/Fixnum}] The version hash
     def version
       return @@version if defined?(@@version)
 
-      numbers = File.read(scope('VERSION')).strip.split('.').
-        map {|n| n =~ /^[0-9]+$/ ? n.to_i : n}
+      numbers = File.read(scope('VERSION')).strip.split('.').map { |n| n.to_i }
       name = File.read(scope('VERSION_NAME')).strip
       @@version = {
         :major => numbers[0],
@@ -51,14 +35,7 @@ module Haml
         :teeny => numbers[2],
         :name => name
       }
-
-      if numbers[3].is_a?(String)
-        @@version[:teeny] = -1
-        @@version[:prerelease] = numbers[3]
-        @@version[:prerelease_number] = numbers[4]
-      end
-
-      @@version[:number] = numbers.join('.')
+      @@version[:number] = [:major, :minor, :teeny].map { |comp| @@version[comp] }.compact.join('.')
       @@version[:string] = @@version[:number].dup
 
       if rev = revision_number

data/vendor/plugins/haml/lib/sass.rb

@@ -5,7 +5,7 @@ require 'haml/version'
 
 # The module that contains everything Sass-related:
 #
-# * {Sass::Engine} is the class used to render Sass/SCSS within Ruby code.
+# * {Sass::Engine} is the class used to render Sass within Ruby code.
 # * {Sass::Plugin} is interfaces with web frameworks (Rails and Merb in particular).
 # * {Sass::SyntaxError} is raised when Sass encounters an error.
 # * {Sass::CSS} handles conversion of CSS to Sass.
@@ -15,15 +15,10 @@ module Sass
   extend Haml::Version
 
   # A string representing the version of Sass.
-  # A more fine-grained representation is available from {Haml::Version#version Sass.version}.
-  # @api public
+  # A more fine-grained representation is available from {Sass.version}.
   VERSION = version[:string] unless defined?(Sass::VERSION)
 end
 
 require 'haml/util'
-
-dir = Haml::Util.scope("vendor/fssm/lib")
-$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
-
 require 'sass/engine'
 require 'sass/plugin' if defined?(Merb::Plugins)

data/vendor/plugins/haml/lib/sass/css.rb

@@ -1,30 +1,69 @@
 require File.dirname(__FILE__) + '/../sass'
 require 'sass/tree/node'
-require 'sass/scss/css_parser'
 require 'strscan'
 
 module Sass
-  # This class converts CSS documents into Sass or SCSS templates.
+  module Tree
+    class Node
+      # Converts a node to Sass code that will generate it.
+      #
+      # @param tabs [Fixnum] The amount of tabulation to use for the Sass code
+      # @param opts [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
+      # @return [String] The Sass code corresponding to the node
+      def to_sass(tabs = 0, opts = {})
+        result = ''
+
+        children.each do |child|
+          result << "#{'  ' * tabs}#{child.to_sass(0, opts)}\n"
+        end
+
+        result
+      end
+    end
+
+    class RuleNode
+      # @see Node#to_sass
+      def to_sass(tabs, opts = {})
+        name = rules.first
+        name = "\\" + name if name[0] == ?:
+        str = "\n#{'  ' * tabs}#{name}#{children.any? { |c| c.is_a? PropNode } ? "\n" : ''}"
+
+        children.each do |child|
+          str << "#{child.to_sass(tabs + 1, opts)}"
+        end
+
+        str
+      end
+    end
+
+    class PropNode
+      # @see Node#to_sass
+      def to_sass(tabs, opts = {})
+        "#{'  ' * tabs}#{opts[:old] ? ':' : ''}#{name}#{opts[:old] ? '' : ':'} #{value}\n"
+      end
+    end
+
+    class DirectiveNode
+      # @see Node#to_sass
+      def to_sass(tabs, opts = {})
+        "#{'  ' * tabs}#{value}#{children.map {|c| c.to_sass(tabs + 1, opts)}}\n"
+      end
+    end
+  end
+
+  # This class converts CSS documents into Sass templates.
   # It works by parsing the CSS document into a {Sass::Tree} structure,
   # and then applying various transformations to the structure
-  # to produce more concise and idiomatic Sass/SCSS.
+  # to produce more concise and idiomatic Sass.
   #
   # Example usage:
   #
-  #     Sass::CSS.new("p { color: blue }").render(:sass) #=> "p\n  color: blue"
-  #     Sass::CSS.new("p { color: blue }").render(:scss) #=> "p {\n  color: blue; }"
+  #     Sass::CSS.new("p { color: blue }").render #=> "p\n  color: blue"
   class CSS
-    # @param template [String] The CSS stylesheet.
-    #   This stylesheet can be encoded using any encoding
-    #   that can be converted to Unicode.
-    #   If the stylesheet contains an `@charset` declaration,
-    #   that overrides the Ruby encoding
-    #   (see {file:SASS_REFERENCE.md#encodings the encoding documentation})
+    # @param template [String] The CSS code
     # @option options :old [Boolean] (false)
     #     Whether or not to output old property syntax
     #     (`:color blue` as opposed to `color: blue`).
-    #     This is only meaningful when generating Sass code,
-    #     rather than SCSS.
     def initialize(template, options = {})
       if template.is_a? IO
         template = template.read
@@ -33,49 +72,32 @@ module Sass
       @options = options.dup
       # Backwards compatibility
       @options[:old] = true if @options[:alternate] == false
-      @template = template
+      @template = StringScanner.new(template)
     end
 
-    # Converts the CSS template into Sass or SCSS code.
-    #
-    # @param fmt [Symbol] `:sass` or `:scss`, designating the format to return.
-    # @return [String] The resulting Sass or SCSS code
-    # @raise [Sass::SyntaxError] if there's an error parsing the CSS template
-    def render(fmt = :sass)
-      check_encoding!
-      build_tree.send("to_#{fmt}", @options).strip + "\n"
-    rescue Sass::SyntaxError => err
-      err.modify_backtrace(:filename => @options[:filename] || '(css)')
-      raise err
-    end
+    # Converts the CSS template into Sass code.
+    #
+    # @return [String] The resulting Sass code
+    def render
+      begin
+        build_tree.to_sass(0, @options).strip + "\n"
+      rescue Exception => err
+        line = @template.string[0...@template.pos].split("\n").size
 
-    # Returns the original encoding of the document,
-    # or `nil` under Ruby 1.8.
-    #
-    # @return [Encoding, nil]
-    # @raise [Encoding::UndefinedConversionError] if the source encoding
-    #   cannot be converted to UTF-8
-    # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
-    def source_encoding
-      check_encoding!
-      @original_encoding
+        err.backtrace.unshift "(css):#{line}"
+        raise err
+      end
     end
 
     private
 
-    def check_encoding!
-      return if @checked_encoding
-      @checked_encoding = true
-      @template, @original_encoding = Haml::Util.check_sass_encoding(@template) do |msg, line|
-        raise Sass::SyntaxError.new(msg, :line => line)
-      end
-    end
-
     # Parses the CSS template and applies various transformations
     #
     # @return [Tree::Node] The root node of the parsed tree
     def build_tree
-      root = Sass::SCSS::CssParser.new(@template).parse
+      root = Tree::Node.new
+      whitespace
+      rules              root
       expand_commas      root
       parent_ref_rules   root
       remove_parent_refs root
@@ -84,6 +106,117 @@ module Sass
       root
     end
 
+    # Parses a set of CSS rules.
+    #
+    # @param root [Tree::Node] The parent node of the rules
+    def rules(root)
+      while r = rule
+        root << r
+        whitespace
+      end
+    end
+
+    # Parses a single CSS rule.
+    #
+    # @return [Tree::Node] The parsed rule
+    def rule
+      rule = ""
+      loop do
+        token = @template.scan(/(?:[^\{\};\/\s]|\/[^*])+/)
+        if token.nil?
+          return if rule.empty?
+          break
+        end
+        rule << token
+        break unless @template.match?(/\s|\/\*/)
+        whitespace
+        rule << " "
+      end
+
+      rule.strip!
+      directive = rule[0] == ?@
+
+      if directive
+        node = Tree::DirectiveNode.new(rule)
+        return node if @template.scan(/;/)
+
+        assert_match /\{/
+        whitespace
+
+        rules(node)
+        return node
+      end
+
+      assert_match /\{/
+      node = Tree::RuleNode.new(rule)
+      properties(node)
+      return node
+    end
+
+    # Parses a set of CSS properties within a rule.
+    #
+    # @param rule [Tree::RuleNode] The parent node of the properties
+    def properties(rule)
+      while @template.scan(/[^:\}\s]+/)
+        name = @template[0]
+        whitespace
+
+        assert_match /:/
+
+        value = ''
+        while @template.scan(/[^;\s\}]+/)
+          value << @template[0] << whitespace
+        end
+
+        assert_match /(;|(?=\}))/
+        rule << Tree::PropNode.new(name, value, nil)
+      end
+
+      assert_match /\}/
+    end
+
+    # Moves the scanner over a section of whitespace or comments.
+    #
+    # @return [String] The ignored whitespace
+    def whitespace
+      space = @template.scan(/\s*/) || ''
+
+      # If we've hit a comment,
+      # go past it and look for more whitespace
+      if @template.scan(/\/\*/)
+        @template.scan_until(/\*\//)
+        return space + whitespace
+      end
+      return space
+    end
+
+    # Moves the scanner over a regular expression,
+    # raising an exception if it doesn't match.
+    #
+    # @param re [Regexp] The regular expression to assert
+    def assert_match(re)
+      if @template.scan(re)
+        whitespace
+        return
+      end
+
+      line = @template.string[0..@template.pos].count "\n"
+      pos = @template.pos
+
+      after = @template.string[pos - 15...pos]
+      after = "..." + after if pos >= 15
+
+      # Display basic regexps as plain old strings
+      expected = re.source == Regexp.escape(re.source) ? "\"#{re.source}\"" : re.inspect
+
+      was = @template.rest[0...15]
+      was += "..." if @template.rest.size >= 15
+      raise Exception.new(<<MESSAGE)
+Invalid CSS on line #{line + 1} after #{after.inspect}:
+  expected #{expected}, was #{was.inspect}
+MESSAGE
+    end
+
     # Transform
     #
     #     foo, bar, baz
@@ -101,12 +234,9 @@ module Sass
     # @param root [Tree::Node] The parent node
     def expand_commas(root)
       root.children.map! do |child|
-        unless child.is_a?(Tree::RuleNode) && child.rule.first.include?(',')
-          expand_commas(child) if child.is_a?(Tree::DirectiveNode)
-          next child
-        end
-        child.rule.first.split(',').map do |rule|
-          node = Tree::RuleNode.new([rule.strip])
+        next child unless Tree::RuleNode === child && child.rules.first.include?(',')
+        child.rules.first.split(',').map do |rule|
+          node = Tree::RuleNode.new(rule.strip)
           node.children = child.children
           node
         end
@@ -150,29 +280,22 @@ module Sass
     # @param root [Tree::Node] The parent node
     def parent_ref_rules(root)
       current_rule = nil
-      root.children.map! do |child|
-        unless child.is_a?(Tree::RuleNode)
-          parent_ref_rules(child) if child.is_a?(Tree::DirectiveNode)
-          next child
-        end
+      root.children.select { |c| Tree::RuleNode === c }.each do |child|
+        root.children.delete child
+        first, rest = child.rules.first.scan(/^(&?(?: .|[^ ])[^.#: \[]*)([.#: \[].*)?$/).first
 
-        first, rest = child.rule.first.scan(/\A(&?(?: .|[^ ])[^.#: \[]*)([.#: \[].*)?\Z/m).first
-
-        if current_rule.nil? || current_rule.rule.first != first
-          current_rule = Tree::RuleNode.new([first])
+        if current_rule.nil? || current_rule.rules.first != first
+          current_rule = Tree::RuleNode.new(first)
+          root << current_rule
         end
 
         if rest
-          child.rule = ["&" + rest]
+          child.rules = ["&" + rest]
           current_rule << child
         else
           current_rule.children += child.children
         end
-
-        current_rule
       end
-      root.children.compact!
-      root.children.uniq!
 
       root.children.each { |v| parent_ref_rules(v) }
     end
@@ -192,11 +315,8 @@ module Sass
     # @param root [Tree::Node] The parent node
     def remove_parent_refs(root)
       root.children.each do |child|
-        case child
-        when Tree::RuleNode
-          child.rule.first.gsub! /^& +/, ''
-          remove_parent_refs child
-        when Tree::DirectiveNode
+        if child.is_a?(Tree::RuleNode)
+          child.rules.first.gsub! /^& +/, ''
           remove_parent_refs child
         end
       end
@@ -226,14 +346,7 @@ module Sass
     #
     # @param root [Tree::Node] The parent node
     def flatten_rules(root)
-      root.children.each do |child|
-        case child
-        when Tree::RuleNode
-          flatten_rule(child)
-        when Tree::DirectiveNode
-          flatten_rules(child)
-        end
-      end
+      root.children.each { |child| flatten_rule(child) if child.is_a?(Tree::RuleNode) }
     end
 
     # Flattens a single rule
@@ -244,10 +357,10 @@ module Sass
       while rule.children.size == 1 && rule.children.first.is_a?(Tree::RuleNode)
         child = rule.children.first
 
-        if child.rule.first[0] == ?&
-          rule.rule = [child.rule.first.gsub(/^&/, rule.rule.first)]
+        if child.rules.first[0] == ?&
+          rule.rules = [child.rules.first.gsub(/^&/, rule.rules.first)]
         else
-          rule.rule = ["#{rule.rule.first} #{child.rule.first}"]
+          rule.rules = ["#{rule.rules.first} #{child.rules.first}"]
         end
 
         rule.children = child.children
@@ -274,13 +387,10 @@ module Sass
     def fold_commas(root)
       prev_rule = nil
       root.children.map! do |child|
-        unless child.is_a?(Tree::RuleNode)
-          fold_commas(child) if child.is_a?(Tree::DirectiveNode)
-          next child
-        end
+        next child unless child.is_a?(Tree::RuleNode)
 
         if prev_rule && prev_rule.children == child.children
-          prev_rule.rule.first << ", #{child.rule.first}"
+          prev_rule.rules.first << ", #{child.rules.first}"
           next nil
         end
 

data/vendor/plugins/haml/lib/sass/engine.rb

@@ -1,7 +1,6 @@
 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'
@@ -9,18 +8,13 @@ require 'sass/tree/directive_node'
 require 'sass/tree/variable_node'
 require 'sass/tree/mixin_def_node'
 require 'sass/tree/mixin_node'
-require 'sass/tree/extend_node'
 require 'sass/tree/if_node'
 require 'sass/tree/while_node'
 require 'sass/tree/for_node'
 require 'sass/tree/debug_node'
-require 'sass/tree/warn_node'
 require 'sass/tree/import_node'
-require 'sass/tree/charset_node'
-require 'sass/selector'
 require 'sass/environment'
 require 'sass/script'
-require 'sass/scss'
 require 'sass/error'
 require 'sass/files'
 require 'haml/shared'
@@ -82,63 +76,68 @@ module Sass
     end
 
     # The character that begins a CSS property.
+    # @private
     PROPERTY_CHAR  = ?:
 
     # The character that designates that
     # a property should be assigned to a SassScript expression.
+    # @private
     SCRIPT_CHAR     = ?=
 
     # The character that designates the beginning of a comment,
     # either Sass or CSS.
+    # @private
     COMMENT_CHAR = ?/
 
     # The character that follows the general COMMENT_CHAR and designates a Sass comment,
     # which is not output as a CSS comment.
+    # @private
     SASS_COMMENT_CHAR = ?/
 
     # The character that follows the general COMMENT_CHAR and designates a CSS comment,
     # which is embedded in the CSS document.
+    # @private
     CSS_COMMENT_CHAR = ?*
 
     # The character used to denote a compiler directive.
+    # @private
     DIRECTIVE_CHAR = ?@
 
     # Designates a non-parsed rule.
+    # @private
     ESCAPE_CHAR    = ?\\
 
     # Designates block as mixin definition rather than CSS rules to output
+    # @private
     MIXIN_DEFINITION_CHAR = ?=
 
     # Includes named mixin declared using MIXIN_DEFINITION_CHAR
+    # @private
     MIXIN_INCLUDE_CHAR    = ?+
 
     # The regex that matches properties of the form `name: prop`.
+    # @private
     PROPERTY_NEW_MATCHER = /^[^\s:"\[]+\s*[=:](\s|$)/
 
     # The regex that matches and extracts data from
     # properties of the form `name: prop`.
-    PROPERTY_NEW = /^([^\s=:"]+)\s*(=|:)(?:\s+|$)(.*)/
+    # @private
+    PROPERTY_NEW = /^([^\s=:"]+)(\s*=|:)(?:\s+|$)(.*)/
 
     # The regex that matches and extracts data from
     # properties of the form `:name prop`.
+    # @private
     PROPERTY_OLD = /^:([^\s=:"]+)\s*(=?)(?:\s+|$)(.*)/
 
     # The default options for Sass::Engine.
-    # @api public
     DEFAULT_OPTIONS = {
       :style => :nested,
       :load_paths => ['.'],
       :cache => true,
       :cache_location => './.sass-cache',
-      :syntax => :sass,
     }.freeze
 
     # @param template [String] The Sass template.
-    #   This template can be encoded using any encoding
-    #   that can be converted to Unicode.
-    #   If the template contains an `@charset` declaration,
-    #   that overrides the Ruby encoding
-    #   (see {file:SASS_REFERENCE.md#encodings the encoding documentation})
     # @param options [{Symbol => Object}] An options hash;
     #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
     def initialize(template, options={})
@@ -161,13 +160,10 @@ module Sass
     #
     # @return [String] The CSS
     # @raise [Sass::SyntaxError] if there's an error in the document
-    # @raise [Encoding::UndefinedConversionError] if the source encoding
-    #   cannot be converted to UTF-8
-    # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
     def render
-      return _render unless @options[:quiet]
-      Haml::Util.silence_haml_warnings {_render}
+      to_tree.render
     end
+
     alias_method :to_css, :render
 
     # Parses the document into its parse tree.
@@ -175,62 +171,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
-      return _to_tree unless @options[:quiet]
-      Haml::Util.silence_haml_warnings {_to_tree}
-    end
-
-    # Returns the original encoding of the document,
-    # or `nil` under Ruby 1.8.
-    #
-    # @return [Encoding, nil]
-    # @raise [Encoding::UndefinedConversionError] if the source encoding
-    #   cannot be converted to UTF-8
-    # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
-    def source_encoding
-      check_encoding!
-      @original_encoding
-    end
-
-    private
-
-    def _render
-      rendered = _to_tree.render
-      return rendered if ruby1_8?
-      begin
-        # Try to convert the result to the original encoding,
-        # but if that doesn't work fall back on UTF-8
-        rendered = rendered.encode(source_encoding)
-      rescue EncodingError
-      end
-      rendered.gsub(Regexp.new('\A@charset "(.*?)"'.encode(source_encoding)),
-        "@charset \"#{source_encoding.name}\"".encode(source_encoding))
-    end
-
-    def _to_tree
-      check_encoding!
-
-      if @options[:syntax] == :scss
-        root = Sass::SCSS::Parser.new(@template).parse
-      else
-        root = Tree::RootNode.new(@template)
-        append_children(root, tree(tabulate(@template)).first, true)
-      end
-
+      root = Tree::Node.new
+      append_children(root, tree(tabulate(@template)).first, true)
       root.options = @options
       root
-    rescue SyntaxError => e
-      e.modify_backtrace(:filename => @options[:filename], :line => @line)
-      e.sass_template = @template
-      raise e
+    rescue SyntaxError => e; e.add_metadata(@options[:filename], @line)
     end
 
-    def check_encoding!
-      return if @checked_encoding
-      @checked_encoding = true
-      @template, @original_encoding = check_sass_encoding(@template) do |msg, line|
-        raise Sass::SyntaxError.new(msg, :line => line)
-      end
-    end
+    private
 
     def tabulate(string)
       tab_str = nil
@@ -254,11 +202,10 @@ module Sass
 
           tab_str ||= line_tab_str
 
-          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)
+          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
         end
         first &&= !tab_str.nil?
         if tab_str.nil?
@@ -267,21 +214,17 @@ module Sass
         end
 
         comment_tab_str ||= line_tab_str
-        if try_comment(line, lines.last, tab_str * lines.last.tabs, comment_tab_str, index)
+        if try_comment(line, lines.last, tab_str * (lines.last.tabs + 1), comment_tab_str, index)
           next
         else
           comment_tab_str = nil
         end
 
         line_tabs = line_tab_str.scan(tab_str).size
-        if tab_str * line_tabs != line_tab_str
-          message = <<END.strip.gsub("\n", ' ')
+        raise SyntaxError.new(<<END.strip.gsub("\n", ' '), index) if tab_str * line_tabs != line_tab_str
 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
@@ -289,11 +232,9 @@ END
 
     def try_comment(line, last, tab_str, comment_tab_str, index)
       return unless last && last.comment?
-      # Nested comment stuff must be at least one whitespace char deeper
-      # than the normal indentation
-      return unless line =~ /^#{tab_str}\s/
+      return unless line =~ /^#{tab_str}/
       unless line =~ /^(?:#{comment_tab_str})(.*)$/
-        raise SyntaxError.new(<<MSG.strip.gsub("\n", " "), :line => index)
+        raise SyntaxError.new(<<MSG.strip.gsub("\n", " "), index)
 Inconsistent indentation:
 previous line was indented by #{Haml::Shared.human_indentation comment_tab_str},
 but this line was indented by #{Haml::Shared.human_indentation line[/^\s*/]}.
@@ -311,8 +252,9 @@ MSG
       nodes = []
       while (line = arr[i]) && line.tabs >= base
         if line.tabs > base
-          raise SyntaxError.new("The line was indented #{line.tabs - base} levels deeper than the previous line.",
-            :line => line.index) if line.tabs > base + 1
+          if line.tabs > base + 1
+            raise SyntaxError.new("The line was indented #{line.tabs - base} levels deeper than the previous line.", line.index)
+          end
 
           nodes.last.children, i = tree(arr, i)
         else
@@ -334,7 +276,11 @@ MSG
         node.line = line.index
         node.filename = line.filename
 
-        append_children(node, line.children, false)
+        if node.is_a?(Tree::CommentNode)
+          node.lines = line.children
+        else
+          append_children(node, line.children, false)
+        end
       end
 
       node_or_nodes
@@ -342,13 +288,11 @@ MSG
 
     def append_children(parent, children, root)
       continued_rule = nil
-      continued_comment = nil
       children.each do |line|
         child = build_tree(parent, line, root)
 
         if child.is_a?(Tree::RuleNode) && child.continued?
-          raise SyntaxError.new("Rules can't end in commas.",
-            :line => child.line) unless child.children.empty?
+          raise SyntaxError.new("Rules can't end in commas.", child.line) unless child.children.empty?
           if continued_rule
             continued_rule.add_rules child
           else
@@ -358,35 +302,31 @@ MSG
         end
 
         if continued_rule
-          raise SyntaxError.new("Rules can't end in commas.",
-            :line => continued_rule.line) unless child.is_a?(Tree::RuleNode)
+          raise SyntaxError.new("Rules can't end in commas.", 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
         end
 
-        if child.is_a?(Tree::CommentNode) && child.silent
-          if continued_comment &&
-              child.line == continued_comment.line +
-              continued_comment.value.count("\n") + 1
-            continued_comment.value << "\n" << child.value
-            next
-          end
-
-          continued_comment = child
-        end
-
         check_for_no_children(child)
         validate_and_append_child(parent, child, line, root)
       end
 
-      raise SyntaxError.new("Rules can't end in commas.",
-        :line => continued_rule.line) if continued_rule
+      raise SyntaxError.new("Rules can't end in commas.", continued_rule.line) if continued_rule
 
       parent
     end
 
     def validate_and_append_child(parent, child, line, root)
+      unless root
+        case child
+        when Tree::MixinDefNode
+          raise SyntaxError.new("Mixins may only be defined at the root of a document.", line.index)
+        when Tree::ImportNode
+          raise SyntaxError.new("Import directives may only be used at the root of a document.", line.index)
+        end
+      end
+
       case child
       when Array
         child.each {|c| validate_and_append_child(parent, c, line, root)}
@@ -397,10 +337,18 @@ MSG
 
     def check_for_no_children(node)
       return unless node.is_a?(Tree::RuleNode) && node.children.empty?
-      Haml::Util.haml_warn(<<WARNING.strip)
+      warning = (node.rules.size == 1) ? <<SHORT : <<LONG
+WARNING on line #{node.line}#{" of #{node.filename}" if node.filename}:
+Selector #{node.rules.first.inspect} doesn't have any properties and will not be rendered.
+SHORT
+
 WARNING on line #{node.line}#{" of #{node.filename}" if node.filename}:
-This selector doesn't have any properties and will not be rendered.
-WARNING
+Selector
+  #{node.rules.join("\n  ")}
+doesn't have any properties and will not be rendered.
+LONG
+
+      warn(warning.strip)
     end
 
     def parse_line(parent, line, root)
@@ -413,100 +361,62 @@ WARNING
           # which begin with ::,
           # as well as pseudo-classes
           # if we're using the new property syntax
-          Tree::RuleNode.new(parse_interp(line.text))
+          Tree::RuleNode.new(line.text)
         else
-          name, eq, value = line.text.scan(PROPERTY_OLD)[0]
-          raise SyntaxError.new("Invalid property: \"#{line.text}\".",
-            :line => @line) if name.nil? || value.nil?
-          parse_property(name, parse_interp(name), eq, value, :old, line)
+          parse_property(line, PROPERTY_OLD)
         end
-      when ?!, ?$
+      when Script::VARIABLE_CHAR
         parse_variable(line)
       when COMMENT_CHAR
         parse_comment(line.text)
       when DIRECTIVE_CHAR
         parse_directive(parent, line, root)
       when ESCAPE_CHAR
-        Tree::RuleNode.new(parse_interp(line.text[1..-1]))
+        Tree::RuleNode.new(line.text[1..-1])
       when MIXIN_DEFINITION_CHAR
         parse_mixin_definition(line)
       when MIXIN_INCLUDE_CHAR
         if line.text[1].nil? || line.text[1] == ?\s
-          Tree::RuleNode.new(parse_interp(line.text))
+          Tree::RuleNode.new(line.text)
         else
           parse_mixin_include(line, root)
         end
       else
-        parse_property_or_rule(line)
+        if line.text =~ PROPERTY_NEW_MATCHER
+          parse_property(line, PROPERTY_NEW)
+        else
+          Tree::RuleNode.new(line.text)
+        end
       end
     end
 
-    def parse_property_or_rule(line)
-      scanner = StringScanner.new(line.text)
-      hack_char = scanner.scan(/[:\*\.]|\#(?!\{)/)
-      parser = Sass::SCSS::SassParser.new(scanner, @line)
-
-      unless res = parser.parse_interp_ident
-        return Tree::RuleNode.new(parse_interp(line.text))
-      end
-      res.unshift(hack_char) if hack_char
-      if comment = scanner.scan(Sass::SCSS::RX::COMMENT)
-        res << comment
-      end
+    def parse_property(line, property_regx)
+      name, eq, value = line.text.scan(property_regx)[0]
 
-      name = line.text[0...scanner.pos]
-      if scanner.scan(/\s*([:=])(?:\s|$)/)
-        parse_property(name, res, scanner[1], scanner.rest, :new, line)
-      else
-        res.pop if comment
-        Tree::RuleNode.new(res + parse_interp(scanner.rest))
+      if name.nil? || value.nil?
+        raise SyntaxError.new("Invalid property: \"#{line.text}\".", @line)
       end
-    end
-
-    def parse_property(name, parsed_name, eq, value, prop, line)
-      if value.strip.empty?
-        expr = Sass::Script::String.new("")
+      expr = if (eq.strip[0] == SCRIPT_CHAR)
+        parse_script(value, :offset => line.offset + line.text.index(value))
       else
-        expr = parse_script(value, :offset => line.offset + line.text.index(value))
-
-        if eq.strip[0] == SCRIPT_CHAR
-          expr.context = :equals
-          Script.equals_warning("properties", name,
-            Sass::Tree::PropNode.val_to_sass(expr, @options), false,
-            @line, line.offset + 1, @options[:filename])
-        end
+        value
       end
-      Tree::PropNode.new(parse_interp(name), expr, prop)
+      Tree::PropNode.new(name, expr, property_regx == PROPERTY_OLD ? :old : :new)
     end
 
     def parse_variable(line)
-      name, op, value, default = line.text.scan(Script::MATCH)[0]
-      guarded = op =~ /^\|\|/
-      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
-      Script.var_warning(name, @line, line.offset + 1, @options[:filename]) if line.text[0] == ?!
-
-      expr = parse_script(value, :offset => line.offset + line.text.index(value))
-      if op =~ /=$/
-        expr.context = :equals
-        type = guarded ? "variable defaults" : "variables"
-        Script.equals_warning(type, "$#{name}", expr.to_sass,
-          guarded, @line, line.offset + 1, @options[:filename])
-      end
+      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
 
-      Tree::VariableNode.new(name, expr, default || guarded)
+      Tree::VariableNode.new(name, parse_script(value, :offset => line.offset + line.text.index(value)), op == '||=')
     end
 
     def parse_comment(line)
       if line[1] == CSS_COMMENT_CHAR || line[1] == SASS_COMMENT_CHAR
-        silent = line[1] == SASS_COMMENT_CHAR
-        Tree::CommentNode.new(
-          format_comment_text(line[2..-1], silent),
-          silent)
+        Tree::CommentNode.new(line, line[1] == SASS_COMMENT_CHAR)
       else
-        Tree::RuleNode.new(parse_interp(line))
+        Tree::RuleNode.new(line)
       end
     end
 
@@ -516,12 +426,9 @@ WARNING
 
       # If value begins with url( or ",
       # it's a CSS @import rule and we don't want to touch it.
-      if directive == "import"
-        parse_import(line, value)
-      elsif directive == "mixin"
-        parse_mixin_definition(line)
-      elsif directive == "include"
-        parse_mixin_include(line, root)
+      if directive == "import" && value !~ /^(url\(|")/
+        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath import directives.", @line + 1) unless line.children.empty?
+        value.split(/,\s*/).map {|f| Tree::ImportNode.new(f)}
       elsif directive == "for"
         parse_for(line, root, value)
       elsif directive == "else"
@@ -534,28 +441,9 @@ WARNING
         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 => @line + 1) unless line.children.empty?
+        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath debug directives.", @line + 1) unless line.children.empty?
         offset = line.offset + line.text.index(value).to_i
         Tree::DebugNode.new(parse_script(value, :offset => offset))
-      elsif directive == "extend"
-        raise SyntaxError.new("Invalid extend directive '@extend': expected expression.") unless value
-        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath extend directives.",
-          :line => @line + 1) unless line.children.empty?
-        offset = line.offset + line.text.index(value).to_i
-        Tree::ExtendNode.new(parse_interp(value, offset))
-      elsif directive == "warn"
-        raise SyntaxError.new("Invalid warn directive '@warn': expected expression.") unless value
-        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath warn directives.",
-          :line => @line + 1) unless line.children.empty?
-        offset = line.offset + line.text.index(value).to_i
-        Tree::WarnNode.new(parse_script(value, :offset => offset))
-      elsif directive == "charset"
-        name = value && value[/\A(["'])(.*)\1\Z/, 2] #"
-        raise SyntaxError.new("Invalid charset directive '@charset': expected string.") unless name
-        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath charset directives.",
-          :line => @line + 1) unless line.children.empty?
-        Tree::CharsetNode.new(name)
       else
         Tree::DirectiveNode.new(line.text)
       end
@@ -572,26 +460,22 @@ WARNING
         else
           expected = "'to <expr>' or 'through <expr>'"
         end
-        raise SyntaxError.new("Invalid for directive '@for #{text}': expected #{expected}.")
-      end
-      raise SyntaxError.new("Invalid variable \"#{var}\".") unless var =~ Script::VALIDATE
-      if var.slice!(0) == ?!
-        offset = line.offset + line.text.index("!" + var) + 1
-        Script.var_warning(var, @line, offset, @options[:filename])
+        raise SyntaxError.new("Invalid for directive '@for #{text}': expected #{expected}.", @line)
       end
+      raise SyntaxError.new("Invalid variable \"#{var}\".", @line) 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))
-      Tree::ForNode.new(var, parsed_from, parsed_to, to_name == 'to')
+      Tree::ForNode.new(var[1..-1], parsed_from, parsed_to, to_name == 'to')
     end
 
     def parse_else(parent, line, text)
-      previous = parent.children.last
+      previous = parent.last
       raise SyntaxError.new("@else must come after @if.") unless previous.is_a?(Tree::IfNode)
 
       if text
         if text !~ /^if\s+(.+)/
-          raise SyntaxError.new("Invalid else directive '@else #{text}': expected 'if <expr>'.")
+          raise SyntaxError.new("Invalid else directive '@else #{text}': expected 'if <expr>'.", @line)
         end
         expr = parse_script($1, :offset => line.offset + line.text.index($1))
       end
@@ -602,119 +486,30 @@ WARNING
       nil
     end
 
-    def parse_import(line, value)
-      raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath import directives.",
-        :line => @line + 1) unless line.children.empty?
-
-      scanner = StringScanner.new(value)
-      values = []
-
-      loop do
-        unless node = parse_import_arg(scanner)
-          raise SyntaxError.new("Invalid @import: expected file to import, was #{scanner.rest.inspect}",
-            :line => @line)
-        end
-        values << node
-        break unless scanner.scan(/,\s*/)
-      end
-
-      return values
-    end
-
-    def parse_import_arg(scanner)
-      return if scanner.eos?
-      unless (str = scanner.scan(Sass::SCSS::RX::STRING)) ||
-          (uri = scanner.scan(Sass::SCSS::RX::URI))
-        return Tree::ImportNode.new(scanner.scan(/[^,]+/))
-      end
-
-      val = scanner[1] || scanner[2]
-      scanner.scan(/\s*/)
-      if media = scanner.scan(/[^,].*/)
-        Tree::DirectiveNode.new("@import #{str || uri} #{media}")
-      elsif uri
-        Tree::DirectiveNode.new("@import #{uri}")
-      elsif val =~ /^http:\/\//
-        Tree::DirectiveNode.new("@import url(#{val})")
-      else
-        Tree::ImportNode.new(val)
-      end
-    end
-
-    MIXIN_DEF_RE = /^(?:=|@mixin)\s*(#{Sass::SCSS::RX::IDENT})(.*)$/
     def parse_mixin_definition(line)
-      name, arg_string = line.text.scan(MIXIN_DEF_RE).first
-      raise SyntaxError.new("Invalid mixin \"#{line.text[1..-1]}\".") if name.nil?
+      name, arg_string = line.text.scan(/^=\s*([^(]+)(.*)$/).first
+      raise SyntaxError.new("Invalid mixin \"#{line.text[1..-1]}\".", @line) if name.nil?
 
       offset = line.offset + line.text.size - arg_string.size
-      args = Script::Parser.new(arg_string.strip, @line, offset, @options).
-        parse_mixin_definition_arglist
+      args = Script::Parser.new(arg_string.strip, @line, offset).parse_mixin_definition_arglist
       default_arg_found = false
       Tree::MixinDefNode.new(name, args)
     end
 
-    MIXIN_INCLUDE_RE = /^(?:\+|@include)\s*(#{Sass::SCSS::RX::IDENT})(.*)$/
     def parse_mixin_include(line, root)
-      name, arg_string = line.text.scan(MIXIN_INCLUDE_RE).first
-      raise SyntaxError.new("Invalid mixin include \"#{line.text}\".") if name.nil?
+      name, arg_string = line.text.scan(/^\+\s*([^(]+)(.*)$/).first
+      raise SyntaxError.new("Invalid mixin include \"#{line.text}\".", @line) if name.nil?
 
       offset = line.offset + line.text.size - arg_string.size
-      args = Script::Parser.new(arg_string.strip, @line, offset, @options).
-        parse_mixin_include_arglist
-      raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath mixin directives.",
-        :line => @line + 1) unless line.children.empty?
+      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?
       Tree::MixinNode.new(name, args)
     end
 
     def parse_script(script, options = {})
       line = options[:line] || @line
       offset = options[:offset] || 0
-      Script.parse(script, line, offset, @options)
-    end
-
-    def format_comment_text(text, silent)
-      content = text.split("\n")
-
-      if content.first && content.first.strip.empty?
-        removed_first = true
-        content.shift
-      end
-
-      return silent ? "//" : "/* */" if content.empty?
-      content.last.gsub!(%r{ ?\*/ *$}, '')
-      content.map! {|l| l.gsub!(/^\*( ?)/, '\1') || (l.empty? ? "" : " ") + l}
-      content.first.gsub!(/^ /, '') unless removed_first
-      if silent
-        "//" + content.join("\n//")
-      else
-        # The #gsub fixes the case of a trailing */
-        "/*" + content.join("\n *").gsub(/ \*\Z/, '') + " */"
-      end
-    end
-
-    def parse_interp(text, offset = 0)
-      self.class.parse_interp(text, @line, offset, :filename => @filename)
-    end
-
-    # It's important that this have strings (at least)
-    # at the beginning, the end, and between each Script::Node.
-    #
-    # @private
-    def self.parse_interp(text, line, offset, options)
-      res = []
-      rest = Haml::Shared.handle_interpolation text do |scan|
-        escapes = scan[2].size
-        res << scan.matched[0...-2 - escapes]
-        if escapes % 2 == 1
-          res << "\\" * (escapes - 1) << '#{'
-        else
-          res << "\\" * [0, escapes - 1].max
-          res << Script::Parser.new(
-            scan, line, offset + scan.pos - scan.matched_size, options).
-            parse_interpolated
-        end
-      end
-      res << rest
+      Script.parse(script, line, offset, @options[:filename])
     end
   end
 end