haml 3.0.21 → 3.0.22

data/vendor/sass/lib/sass/callbacks.rb

@@ -1,66 +0,0 @@
-module Sass
-  # A lightweight infrastructure for defining and running callbacks.
-  # Callbacks are defined using \{#define\_callback\} at the class level,
-  # and called using `run_#{name}` at the instance level.
-  #
-  # Clients can add callbacks by calling the generated `on_#{name}` method,
-  # and passing in a block that's run when the callback is activated.
-  #
-  # @example Define a callback
-  #   class Munger
-  #     extend Sass::Callbacks
-  #     define_callback :string_munged
-  #
-  #     def munge(str)
-  #       res = str.gsub(/[a-z]/, '\1\1')
-  #       run_string_munged str, res
-  #       res
-  #     end
-  #   end
-  #
-  # @example Use a callback
-  #   m = Munger.new
-  #   m.on_string_munged {|str, res| puts "#{str} was munged into #{res}!"}
-  #   m.munge "bar" #=> bar was munged into bbaarr!
-  module Callbacks
-    # Automatically includes {InstanceMethods}
-    # when something extends this module.
-    #
-    # @param base [Module]
-    def self.extended(base)
-      base.send(:include, InstanceMethods)
-    end
-    protected
-
-    module InstanceMethods
-      # Removes all callbacks registered against this object.
-      def clear_callbacks!
-        @_sass_callbacks = {}
-      end
-    end
-
-    # Define a callback with the given name.
-    # This will define an `on_#{name}` method
-    # that registers a block,
-    # and a `run_#{name}` method that runs that block
-    # (optionall with some arguments).
-    #
-    # @param name [Symbol] The name of the callback
-    # @return [void]
-    def define_callback(name)
-      class_eval <<RUBY
-def on_#{name}(&block)
-  @_sass_callbacks ||= {}
-  (@_sass_callbacks[#{name.inspect}] ||= []) << block
-end
-
-def run_#{name}(*args)
-  return unless @_sass_callbacks
-  return unless @_sass_callbacks[#{name.inspect}]
-  @_sass_callbacks[#{name.inspect}].each {|c| c[*args]}
-end
-private :run_#{name}
-RUBY
-    end
-  end
-end

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

@@ -1,294 +0,0 @@
-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 = Sass::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/sass/lib/sass/engine.rb

@@ -1,792 +0,0 @@
-require 'strscan'
-require 'digest/sha1'
-require 'sass/cache_store'
-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/selector'
-require 'sass/environment'
-require 'sass/script'
-require 'sass/scss'
-require 'sass/error'
-require 'sass/importers'
-require 'sass/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 Sass::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,
-      :filesystem_importer => Sass::Importers::Filesystem
-    }.freeze
-
-    # Converts a Sass options hash into a standard form, filling in
-    # default values and resolving aliases.
-    #
-    # @param options [{Symbol => Object}] The options hash;
-    #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
-    # @return [{Symbol => Object}] The normalized options hash.
-    # @private
-    def self.normalize_options(options)
-      options = DEFAULT_OPTIONS.merge(options.reject {|k, v| v.nil?})
-
-      # If the `:filename` option is passed in without an importer,
-      # assume it's using the default filesystem importer.
-      options[:importer] ||= options[:filesystem_importer].new(".") if options[:filename]
-
-      # Tracks the original filename of the top-level Sass file
-      options[:original_filename] = options[:original_filename] || options[:filename]
-
-      options[:cache_store] ||= Sass::FileCacheStore.new(options[:cache_location])
-      # Support both, because the docs said one and the other actually worked
-      # for quite a long time.
-      options[:line_comments] ||= options[:line_numbers]
-
-      options[:load_paths] = options[:load_paths].map do |p|
-        next p unless p.is_a?(String)
-        options[:filesystem_importer].new(p)
-      end
-
-      # 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
-
-      options
-    end
-
-    # Returns the {Sass::Engine} for the given file.
-    # This is preferable to Sass::Engine.new when reading from a file
-    # because it properly sets up the Engine's metadata,
-    # enables parse-tree caching,
-    # and infers the syntax from the filename.
-    #
-    # @param filename [String] The path to the Sass or SCSS file
-    # @param options [{Symbol => Object}] The options hash;
-    #   See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
-    # @return [Sass::Engine] The Engine for the given Sass or SCSS file.
-    # @raise [Sass::SyntaxError] if there's an error in the document.
-    def self.for_file(filename, options)
-      had_syntax = options[:syntax]
-
-      if had_syntax
-        # Use what was explicitly specificed
-      elsif filename =~ /\.scss$/
-        options.merge!(:syntax => :scss)
-      elsif filename =~ /\.sass$/
-        options.merge!(:syntax => :sass)
-      end
-
-      Sass::Engine.new(File.read(filename), options.merge(:filename => filename))
-    end
-
-    # The options for the Sass engine.
-    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
-    #
-    # @return [{Symbol => Object}]
-    attr_reader :options
-
-    # Creates a new Engine. Note that Engine should only be used directly
-    # when compiling in-memory Sass code.
-    # If you're compiling a single Sass file from the filesystem,
-    # use \{Sass::Engine.for\_file}.
-    # If you're compiling multiple files from the filesystem,
-    # use {Sass::Plugin.
-    #
-    # @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}.
-    # @see {Sass::Engine.for_file}
-    # @see {Sass::Plugin}
-    def initialize(template, options={})
-      @options = self.class.normalize_options(options)
-      @template = template
-    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]
-      Sass::Util.silence_sass_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]
-      Sass::Util.silence_sass_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?
-      return rendered.encode(source_encoding)
-    end
-
-    def _to_tree
-      if (@options[:cache] || @options[:read_cache]) &&
-          @options[:filename] && @options[:importer]
-        key = sassc_key
-        sha = Digest::SHA1.hexdigest(@template)
-
-        if root = @options[:cache_store].retrieve(key, sha)
-          @options = root.options.merge(@options)
-          root.options = @options
-          return root
-        end
-      end
-
-      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
-      @options[:cache_store].store(key, sha, root) if @options[:cache] && key && sha
-      root
-    rescue SyntaxError => e
-      e.modify_backtrace(:filename => @options[:filename], :line => @line)
-      e.sass_template = @template
-      raise e
-    end
-
-    def sassc_key
-      @options[:cache_store].key(*@options[:importer].key(@options[:filename], @options))
-    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: #{Sass::Shared.human_indentation line_tab_str, true} used for indentation,
-but the rest of the document was indented using #{Sass::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 #{Sass::Shared.human_indentation comment_tab_str},
-but this line was indented by #{Sass::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?
-      Sass::Util.sass_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))
-      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 = Sass::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