radiantcms-couchrest_model 0.1

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

@@ -0,0 +1,102 @@
+require 'haml/util'
+
+module Haml
+  # Handles Haml version-reporting.
+  # Haml not only reports the standard three version numbers,
+  # but its Git revision hash as well,
+  # if it was installed from Git.
+  module Version
+    include Haml::Util
+
+    # Returns a hash representing the version of Haml.
+    # The `:major`, `:minor`, and `:teeny` keys have their respective numbers as Fixnums.
+    # The `:name` key has the name of the version.
+    # The `:string` key contains a human-readable string representation of the version.
+    # The `:number` key is the major, minor, and teeny keys separated by periods.
+    # If Haml is checked out from Git, the `:rev` key will have the revision hash.
+    # For example:
+    #
+    #     {
+    #       :string => "2.1.0.9616393",
+    #       :rev    => "9616393b8924ef36639c7e82aa88a51a24d16949",
+    #       :number => "2.1.0",
+    #       :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}
+      name = File.read(scope('VERSION_NAME')).strip
+      @@version = {
+        :major => numbers[0],
+        :minor => numbers[1],
+        :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[:string] = @@version[:number].dup
+
+      if rev = revision_number
+        @@version[:rev] = rev
+        unless rev[0] == ?(
+          @@version[:string] << "." << rev[0...7]
+        end
+      end
+
+      @@version[:string] << " (#{name})"
+      @@version
+    end
+
+    private
+
+    def revision_number
+      if File.exists?(scope('REVISION'))
+        rev = File.read(scope('REVISION')).strip
+        return rev unless rev =~ /^([a-f0-9]+|\(.*\))$/ || rev == '(unknown)'
+      end
+
+      return unless File.exists?(scope('.git/HEAD'))
+      rev = File.read(scope('.git/HEAD')).strip
+      return rev unless rev =~ /^ref: (.*)$/
+
+      ref_name = $1
+      ref_file = scope(".git/#{ref_name}")
+      info_file = scope(".git/info/refs")
+      return File.read(ref_file).strip if File.exists?(ref_file)
+      return unless File.exists?(info_file)
+      File.open(info_file) do |f|
+        f.each do |l|
+          sha, ref = l.strip.split("\t", 2)
+          next unless ref == ref_name
+          return sha
+        end
+      end
+      return nil
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+require 'haml/version'
+
+# The module that contains everything Sass-related:
+#
+# * {Sass::Engine} is the class used to render Sass/SCSS 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.
+#
+# Also see the {file:SASS_REFERENCE.md full Sass reference}.
+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
+  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

@@ -0,0 +1,294 @@
+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.
+  # 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.
+  #
+  # 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; }"
+  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})
+    # @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
+      end
+
+      @options = options.dup
+      # Backwards compatibility
+      @options[:old] = true if @options[:alternate] == false
+      @template = 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
+
+    # 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 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
+      expand_commas      root
+      parent_ref_rules   root
+      remove_parent_refs root
+      flatten_rules      root
+      fold_commas        root
+      root
+    end
+
+    # Transform
+    #
+    #     foo, bar, baz
+    #       color: blue
+    #
+    # into
+    #
+    #     foo
+    #       color: blue
+    #     bar
+    #       color: blue
+    #     baz
+    #       color: blue
+    #
+    # @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])
+          node.children = child.children
+          node
+        end
+      end
+      root.children.flatten!
+    end
+
+    # Make rules use parent refs so that
+    #
+    #     foo
+    #       color: green
+    #     foo.bar
+    #       color: blue
+    #
+    # becomes
+    #
+    #     foo
+    #       color: green
+    #       &.bar
+    #         color: blue
+    #
+    # This has the side effect of nesting rules,
+    # so that
+    #
+    #     foo
+    #       color: green
+    #     foo bar
+    #       color: red
+    #     foo baz
+    #       color: blue
+    #
+    # becomes
+    #
+    #     foo
+    #       color: green
+    #       & bar
+    #         color: red
+    #       & baz
+    #         color: blue
+    #
+    # @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
+
+        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])
+        end
+
+        if rest
+          child.rule = ["&" + 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
+
+    # Remove useless parent refs so that
+    #
+    #     foo
+    #       & bar
+    #         color: blue
+    #
+    # becomes
+    #
+    #     foo
+    #       bar
+    #         color: blue
+    #
+    # @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
+          remove_parent_refs child
+        end
+      end
+    end
+
+    # Flatten rules so that
+    #
+    #     foo
+    #       bar
+    #         color: red
+    #
+    # becomes
+    #
+    #     foo bar
+    #       color: red
+    #
+    # and
+    #
+    #     foo
+    #       &.bar
+    #         color: blue
+    #
+    # becomes
+    #
+    #     foo.bar
+    #       color: blue
+    #
+    # @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
+    end
+
+    # Flattens a single rule
+    #
+    # @param rule [Tree::RuleNode] The candidate for flattening
+    # @see #flatten_rules
+    def flatten_rule(rule)
+      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)]
+        else
+          rule.rule = ["#{rule.rule.first} #{child.rule.first}"]
+        end
+
+        rule.children = child.children
+      end
+
+      flatten_rules(rule)
+    end
+
+    # Transform
+    #
+    #     foo
+    #       bar
+    #         color: blue
+    #       baz
+    #         color: blue
+    #
+    # into
+    #
+    #     foo
+    #       bar, baz
+    #         color: blue
+    #
+    # @param rule [Tree::RuleNode] The candidate for flattening
+    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
+
+        if prev_rule && prev_rule.children == child.children
+          prev_rule.rule.first << ", #{child.rule.first}"
+          next nil
+        end
+
+        fold_commas(child)
+        prev_rule = child
+        child
+      end
+      root.children.compact!
+    end
+  end
+end

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

@@ -0,0 +1,720 @@
+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'
+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'
+
+module Sass
+  # A Sass mixin.
+  #
+  # `name`: `String`
+  # : The name of the mixin.
+  #
+  # `args`: `Array<(String, Script::Node)>`
+  # : The arguments for the mixin.
+  #   Each element is a tuple containing the name of the argument
+  #   and the parse tree for the default value of the argument.
+  #
+  # `environment`: {Sass::Environment}
+  # : The environment in which the mixin was defined.
+  #   This is captured so that the mixin can have access
+  #   to local variables defined in its scope.
+  #
+  # `tree`: {Sass::Tree::Node}
+  # : The parse tree for the mixin.
+  Mixin = Struct.new(:name, :args, :environment, :tree)
+
+  # This class handles the parsing and compilation of the Sass template.
+  # Example usage:
+  #
+  #     template = File.load('stylesheets/sassy.sass')
+  #     sass_engine = Sass::Engine.new(template)
+  #     output = sass_engine.render
+  #     puts output
+  class Engine
+    include Haml::Util
+
+    # A line of Sass code.
+    #
+    # `text`: `String`
+    # : The text in the line, without any whitespace at the beginning or end.
+    #
+    # `tabs`: `Fixnum`
+    # : The level of indentation of the line.
+    #
+    # `index`: `Fixnum`
+    # : The line number in the original document.
+    #
+    # `offset`: `Fixnum`
+    # : The number of bytes in on the line that the text begins.
+    #   This ends up being the number of bytes of leading whitespace.
+    #
+    # `filename`: `String`
+    # : The name of the file in which this line appeared.
+    #
+    # `children`: `Array<Line>`
+    # : The lines nested below this one.
+    class Line < Struct.new(:text, :tabs, :index, :offset, :filename, :children)
+      def comment?
+        text[0] == COMMENT_CHAR && (text[1] == SASS_COMMENT_CHAR || text[1] == CSS_COMMENT_CHAR)
+      end
+    end
+
+    # The character that begins a CSS property.
+    PROPERTY_CHAR  = ?:
+
+    # The character that designates that
+    # a property should be assigned to a SassScript expression.
+    SCRIPT_CHAR     = ?=
+
+    # The character that designates the beginning of a comment,
+    # either Sass or CSS.
+    COMMENT_CHAR = ?/
+
+    # The character that follows the general COMMENT_CHAR and designates a Sass comment,
+    # which is not output as a CSS comment.
+    SASS_COMMENT_CHAR = ?/
+
+    # The character that follows the general COMMENT_CHAR and designates a CSS comment,
+    # which is embedded in the CSS document.
+    CSS_COMMENT_CHAR = ?*
+
+    # The character used to denote a compiler directive.
+    DIRECTIVE_CHAR = ?@
+
+    # Designates a non-parsed rule.
+    ESCAPE_CHAR    = ?\\
+
+    # Designates block as mixin definition rather than CSS rules to output
+    MIXIN_DEFINITION_CHAR = ?=
+
+    # Includes named mixin declared using MIXIN_DEFINITION_CHAR
+    MIXIN_INCLUDE_CHAR    = ?+
+
+    # The regex that matches properties of the form `name: prop`.
+    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+|$)(.*)/
+
+    # The regex that matches and extracts data from
+    # properties of the form `:name prop`.
+    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={})
+      @options = DEFAULT_OPTIONS.merge(options.reject {|k, v| v.nil?})
+      @template = template
+
+      # Support both, because the docs said one and the other actually worked
+      # for quite a long time.
+      @options[:line_comments] ||= @options[:line_numbers]
+
+      # Backwards compatibility
+      @options[:property_syntax] ||= @options[:attribute_syntax]
+      case @options[:property_syntax]
+      when :alternate; @options[:property_syntax] = :new
+      when :normal; @options[:property_syntax] = :old
+      end
+    end
+
+    # Render the template to CSS.
+    #
+    # @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}
+    end
+    alias_method :to_css, :render
+
+    # Parses the document into its parse tree.
+    #
+    # @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.options = @options
+      root
+    rescue SyntaxError => e
+      e.modify_backtrace(:filename => @options[:filename], :line => @line)
+      e.sass_template = @template
+      raise e
+    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
+
+    def tabulate(string)
+      tab_str = nil
+      comment_tab_str = nil
+      first = true
+      lines = []
+      string.gsub(/\r|\n|\r\n|\r\n/, "\n").scan(/^.*?$/).each_with_index do |line, index|
+        index += (@options[:line] || 1)
+        if line.strip.empty?
+          lines.last.text << "\n" if lines.last && lines.last.comment?
+          next
+        end
+
+        line_tab_str = line[/^\s*/]
+        unless line_tab_str.empty?
+          if tab_str.nil?
+            comment_tab_str ||= line_tab_str
+            next if try_comment(line, lines.last, "", comment_tab_str, index)
+            comment_tab_str = nil
+          end
+
+          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)
+        end
+        first &&= !tab_str.nil?
+        if tab_str.nil?
+          lines << Line.new(line.strip, 0, index, 0, @options[:filename], [])
+          next
+        end
+
+        comment_tab_str ||= line_tab_str
+        if try_comment(line, lines.last, tab_str * lines.last.tabs, 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", ' ')
+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
+    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/
+      unless line =~ /^(?:#{comment_tab_str})(.*)$/
+        raise SyntaxError.new(<<MSG.strip.gsub("\n", " "), :line => 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*/]}.
+MSG
+      end
+
+      last.text << "\n" << $1
+      true
+    end
+
+    def tree(arr, i = 0)
+      return [], i if arr[i].nil?
+
+      base = arr[i].tabs
+      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
+
+          nodes.last.children, i = tree(arr, i)
+        else
+          nodes << line
+          i += 1
+        end
+      end
+      return nodes, i
+    end
+
+    def build_tree(parent, line, root = false)
+      @line = line.index
+      node_or_nodes = parse_line(parent, line, root)
+
+      Array(node_or_nodes).each do |node|
+        # Node is a symbol if it's non-outputting, like a variable assignment
+        next unless node.is_a? Tree::Node
+
+        node.line = line.index
+        node.filename = line.filename
+
+        append_children(node, line.children, false)
+      end
+
+      node_or_nodes
+    end
+
+    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?
+          if continued_rule
+            continued_rule.add_rules child
+          else
+            continued_rule = child
+          end
+          next
+        end
+
+        if continued_rule
+          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
+        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
+
+      parent
+    end
+
+    def validate_and_append_child(parent, child, line, root)
+      case child
+      when Array
+        child.each {|c| validate_and_append_child(parent, c, line, root)}
+      when Tree::Node
+        parent << child
+      end
+    end
+
+    def check_for_no_children(node)
+      return unless node.is_a?(Tree::RuleNode) && node.children.empty?
+      Haml::Util.haml_warn(<<WARNING.strip)
+WARNING on line #{node.line}#{" of #{node.filename}" if node.filename}:
+This selector doesn't have any properties and will not be rendered.
+WARNING
+    end
+
+    def parse_line(parent, line, root)
+      case line.text[0]
+      when PROPERTY_CHAR
+        if line.text[1] == PROPERTY_CHAR ||
+            (@options[:property_syntax] == :new &&
+             line.text =~ PROPERTY_OLD && $3.empty?)
+          # Support CSS3-style pseudo-elements,
+          # which begin with ::,
+          # as well as pseudo-classes
+          # if we're using the new property syntax
+          Tree::RuleNode.new(parse_interp(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)
+        end
+      when ?!, ?$
+        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]))
+      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))
+        else
+          parse_mixin_include(line, root)
+        end
+      else
+        parse_property_or_rule(line)
+      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
+
+      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))
+      end
+    end
+
+    def parse_property(name, parsed_name, eq, value, prop, line)
+      if value.strip.empty?
+        expr = Sass::Script::String.new("")
+      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
+      end
+      Tree::PropNode.new(parse_interp(name), expr, prop)
+    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
+
+      Tree::VariableNode.new(name, expr, default || guarded)
+    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)
+      else
+        Tree::RuleNode.new(parse_interp(line))
+      end
+    end
+
+    def parse_directive(parent, line, root)
+      directive, whitespace, value = line.text[1..-1].split(/(\s+)/, 2)
+      offset = directive.size + whitespace.size + 1 if whitespace
+
+      # 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)
+      elsif directive == "for"
+        parse_for(line, root, value)
+      elsif directive == "else"
+        parse_else(parent, line, value)
+      elsif directive == "while"
+        raise SyntaxError.new("Invalid while directive '@while': expected expression.") unless value
+        Tree::WhileNode.new(parse_script(value, :offset => offset))
+      elsif directive == "if"
+        raise SyntaxError.new("Invalid if directive '@if': expected expression.") unless value
+        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?
+        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
+    end
+
+    def parse_for(line, root, text)
+      var, from_expr, to_name, to_expr = text.scan(/^([^\s]+)\s+from\s+(.+)\s+(to|through)\s+(.+)$/).first
+
+      if var.nil? # scan failed, try to figure out why for error message
+        if text !~ /^[^\s]+/
+          expected = "variable name"
+        elsif text !~ /^[^\s]+\s+from\s+.+/
+          expected = "'from <expr>'"
+        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])
+      end
+
+      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')
+    end
+
+    def parse_else(parent, line, text)
+      previous = parent.children.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>'.")
+        end
+        expr = parse_script($1, :offset => line.offset + line.text.index($1))
+      end
+
+      node = Tree::IfNode.new(expr)
+      append_children(node, line.children, false)
+      previous.add_else node
+      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?
+
+      offset = line.offset + line.text.size - arg_string.size
+      args = Script::Parser.new(arg_string.strip, @line, offset, @options).
+        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?
+
+      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?
+      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
+    end
+  end
+end