oreorenasass 3.4.4 → 3.4.5

data/lib/sass/engine.rb

@@ -1,9 +1,6 @@
 require 'set'
 require 'digest/sha1'
 require 'sass/cache_stores'
-require 'sass/source/position'
-require 'sass/source/range'
-require 'sass/source/map'
 require 'sass/tree/node'
 require 'sass/tree/root_node'
 require 'sass/tree/rule_node'
@@ -29,9 +26,6 @@ require 'sass/tree/debug_node'
 require 'sass/tree/warn_node'
 require 'sass/tree/import_node'
 require 'sass/tree/charset_node'
-require 'sass/tree/at_root_node'
-require 'sass/tree/keyframe_rule_node'
-require 'sass/tree/error_node'
 require 'sass/tree/visitors/base'
 require 'sass/tree/visitors/perform'
 require 'sass/tree/visitors/cssize'
@@ -45,7 +39,6 @@ require 'sass/selector'
 require 'sass/environment'
 require 'sass/script'
 require 'sass/scss'
-require 'sass/stack'
 require 'sass/error'
 require 'sass/importers'
 require 'sass/shared'
@@ -53,17 +46,18 @@ require 'sass/media'
 require 'sass/supports'
 
 module Sass
+
   # A Sass mixin or function.
   #
   # `name`: `String`
   # : The name of the mixin/function.
   #
-  # `args`: `Array<(Script::Tree::Node, Script::Tree::Node)>`
+  # `args`: `Array<(Script::Node, Script::Node)>`
   # : The arguments for the mixin/function.
   #   Each element is a tuple containing the variable node of the argument
   #   and the parse tree for the default value of the argument.
   #
-  # `splat`: `Script::Tree::Node?`
+  # `splat`: `Script::Node?`
   # : The variable node of the splat argument for this callable, or null.
   #
   # `environment`: {Sass::Environment}
@@ -89,6 +83,8 @@ module Sass
   #     output = sass_engine.render
   #     puts output
   class Engine
+    include Sass::Util
+
     # A line of Sass code.
     #
     # `text`: `String`
@@ -198,8 +194,6 @@ module Sass
       when :alternate; options[:property_syntax] = :new
       when :normal; options[:property_syntax] = :old
       end
-      options[:sourcemap] = :auto if options[:sourcemap] == true
-      options[:sourcemap] = :none if options[:sourcemap] == false
 
       options
     end
@@ -252,7 +246,7 @@ module Sass
     #   See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
     # @see {Sass::Engine.for_file}
     # @see {Sass::Plugin}
-    def initialize(template, options = {})
+    def initialize(template, options={})
       @options = self.class.normalize_options(options)
       @template = template
     end
@@ -265,27 +259,9 @@ module Sass
     #   cannot be converted to UTF-8
     # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
     def render
-      return _to_tree.render unless @options[:quiet]
-      Sass::Util.silence_sass_warnings {_to_tree.render}
+      return _render unless @options[:quiet]
+      Sass::Util.silence_sass_warnings {_render}
     end
-
-    # Render the template to CSS and return the source map.
-    #
-    # @param sourcemap_uri [String] The sourcemap URI to use in the
-    #   `@sourceMappingURL` comment. If this is relative, it should be relative
-    #   to the location of the CSS file.
-    # @return [(String, Sass::Source::Map)] The rendered CSS and the associated
-    #   source map
-    # @raise [Sass::SyntaxError] if there's an error in the document, or if the
-    #   public URL for this document couldn't be determined.
-    # @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_with_sourcemap(sourcemap_uri)
-      return _render_with_sourcemap(sourcemap_uri) unless @options[:quiet]
-      Sass::Util.silence_sass_warnings {_render_with_sourcemap(sourcemap_uri)}
-    end
-
     alias_method :to_css, :render
 
     # Parses the document into its parse tree. Memoized.
@@ -293,11 +269,9 @@ 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
-      @tree ||= if @options[:quiet]
-                  Sass::Util.silence_sass_warnings {_to_tree}
-                else
-                  _to_tree
-                end
+      @tree ||= @options[:quiet] ?
+        Sass::Util.silence_sass_warnings {_to_tree} :
+        _to_tree
     end
 
     # Returns the original encoding of the document,
@@ -309,7 +283,7 @@ module Sass
     # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
     def source_encoding
       check_encoding!
-      @source_encoding
+      @original_encoding
     end
 
     # Gets a set of all the documents
@@ -326,8 +300,7 @@ module Sass
     #
     # @private
     def _dependencies(seen, engines)
-      key = [@options[:filename], @options[:importer]]
-      return if seen.include?(key)
+      return if seen.include?(key = [@options[:filename], @options[:importer]])
       seen << key
       engines << self
       to_tree.grep(Tree::ImportNode) do |n|
@@ -338,59 +311,35 @@ module Sass
 
     private
 
-    def _render_with_sourcemap(sourcemap_uri)
-      filename = @options[:filename]
-      importer = @options[:importer]
-      sourcemap_dir = @options[:sourcemap_filename] &&
-        File.dirname(File.expand_path(@options[:sourcemap_filename]))
-      if filename.nil?
-        raise Sass::SyntaxError.new(<<ERR)
-Error generating source map: couldn't determine public URL for the source stylesheet.
-  No filename is available so there's nothing for the source map to link to.
-ERR
-      elsif importer.nil?
-        raise Sass::SyntaxError.new(<<ERR)
-Error generating source map: couldn't determine public URL for "#{filename}".
-  Without a public URL, there's nothing for the source map to link to.
-  An importer was not set for this file.
-ERR
-      elsif Sass::Util.silence_warnings do
-              sourcemap_dir = nil if @options[:sourcemap] == :file
-              importer.public_url(filename, sourcemap_dir).nil?
-            end
-        raise Sass::SyntaxError.new(<<ERR)
-Error generating source map: couldn't determine public URL for "#{filename}".
-  Without a public URL, there's nothing for the source map to link to.
-  Custom importers should define the #public_url method.
-ERR
+    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, sourcemap = _to_tree.render_with_sourcemap
-      compressed = @options[:style] == :compressed
-      rendered << "\n" if rendered[-1] != ?\n
-      rendered << "\n" unless compressed
-      rendered << "/*# sourceMappingURL="
-      rendered << Sass::Util.escape_uri(sourcemap_uri)
-      rendered << " */\n"
-      return rendered, sourcemap
+      rendered.gsub(Regexp.new('\A@charset "(.*?)"'.encode(source_encoding)),
+        "@charset \"#{source_encoding.name}\"".encode(source_encoding))
     end
 
     def _to_tree
-      check_encoding!
-
       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))
+        if root = @options[:cache_store].retrieve(key, sha)
           root.options = @options
           return root
         end
       end
 
+      check_encoding!
+
       if @options[:syntax] == :scss
-        root = Sass::SCSS::Parser.new(@template, @options[:filename], @options[:importer]).parse
+        root = Sass::SCSS::Parser.new(@template, @options[:filename]).parse
       else
         root = Tree::RootNode.new(@template)
         append_children(root, tree(tabulate(@template)).first, true)
@@ -420,7 +369,9 @@ ERR
     def check_encoding!
       return if @checked_encoding
       @checked_encoding = true
-      @template, @source_encoding = Sass::Util.check_sass_encoding(@template)
+      @template, @original_encoding = check_sass_encoding(@template) do |msg, line|
+        raise Sass::SyntaxError.new(msg, :line => line)
+      end
     end
 
     def tabulate(string)
@@ -428,7 +379,7 @@ ERR
       comment_tab_str = nil
       first = true
       lines = []
-      string.scan(/^[^\n]*?$/).each_with_index do |line, index|
+      string.gsub(/\r\n|\r|\n/, "\n").scan(/^[^\n]*?$/).each_with_index do |line, index|
         index += (@options[:line] || 1)
         if line.strip.empty?
           lines.last.text << "\n" if lines.last && lines.last.comment?
@@ -473,15 +424,12 @@ END
           raise SyntaxError.new(message, :line => index)
         end
 
-        lines << Line.new(line.strip, line_tabs, index, line_tab_str.size, @options[:filename], [])
+        lines << Line.new(line.strip, line_tabs, index, tab_str.size, @options[:filename], [])
       end
       lines
     end
 
-    # @comment
-    #   rubocop:disable ParameterLists
     def try_comment(line, last, tab_str, comment_tab_str, index)
-      # rubocop:enable ParameterLists
       return unless last && last.comment?
       # Nested comment stuff must be at least one whitespace char deeper
       # than the normal indentation
@@ -506,8 +454,7 @@ 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.",
+          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)
@@ -521,7 +468,6 @@ MSG
 
     def build_tree(parent, line, root = false)
       @line = line.index
-      @offset = line.offset
       node_or_nodes = parse_line(parent, line, root)
 
       Array(node_or_nodes).each do |node|
@@ -564,8 +510,6 @@ MSG
           if continued_comment &&
               child.line == continued_comment.line +
               continued_comment.lines + 1
-            continued_comment.value.last.sub!(/ \*\/\Z/, '')
-            child.value.first.gsub!(/\A\/\*/, ' *')
             continued_comment.value += ["\n"] + child.value
             next
           end
@@ -607,25 +551,12 @@ WARNING
           # which begin with ::,
           # as well as pseudo-classes
           # if we're using the new property syntax
-          Tree::RuleNode.new(parse_interp(line.text), full_line_range(line))
+          Tree::RuleNode.new(parse_interp(line.text))
         else
-          name_start_offset = line.offset + 1 # +1 for the leading ':'
           name, value = line.text.scan(PROPERTY_OLD)[0]
           raise SyntaxError.new("Invalid property: \"#{line.text}\".",
             :line => @line) if name.nil? || value.nil?
-
-          value_start_offset = name_end_offset = name_start_offset + name.length
-          unless value.empty?
-            # +1 and -1 both compensate for the leading ':', which is part of line.text
-            value_start_offset = name_start_offset + line.text.index(value, name.length + 1) - 1
-          end
-
-          property = parse_property(name, parse_interp(name), value, :old, line, value_start_offset)
-          property.name_source_range = Sass::Source::Range.new(
-            Sass::Source::Position.new(@line, to_parser_offset(name_start_offset)),
-            Sass::Source::Position.new(@line, to_parser_offset(name_end_offset)),
-            @options[:filename], @options[:importer])
-          property
+          parse_property(name, parse_interp(name), value, :old, line)
         end
       when ?$
         parse_variable(line)
@@ -634,12 +565,12 @@ WARNING
       when DIRECTIVE_CHAR
         parse_directive(parent, line, root)
       when ESCAPE_CHAR
-        Tree::RuleNode.new(parse_interp(line.text[1..-1]), full_line_range(line))
+        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), full_line_range(line))
+          Tree::RuleNode.new(parse_interp(line.text))
         else
           parse_mixin_include(line, root)
         end
@@ -651,70 +582,32 @@ WARNING
     def parse_property_or_rule(line)
       scanner = Sass::Util::MultibyteStringScanner.new(line.text)
       hack_char = scanner.scan(/[:\*\.]|\#(?!\{)/)
-      offset = line.offset
-      offset += hack_char.length if hack_char
-      parser = Sass::SCSS::Parser.new(scanner,
-        @options[:filename], @options[:importer],
-        @line, to_parser_offset(offset))
-
-      unless (res = parser.parse_interp_ident)
-        parsed = parse_interp(line.text, line.offset)
-        return Tree::RuleNode.new(parsed, full_line_range(line))
-      end
+      parser = Sass::SCSS::Parser.new(scanner, @options[:filename], @line)
 
-      ident_range = Sass::Source::Range.new(
-        Sass::Source::Position.new(@line, to_parser_offset(line.offset)),
-        Sass::Source::Position.new(@line, parser.offset),
-        @options[:filename], @options[:importer])
-      offset = parser.offset - 1
+      unless res = parser.parse_interp_ident
+        return Tree::RuleNode.new(parse_interp(line.text))
+      end
       res.unshift(hack_char) if hack_char
-
-      # Handle comments after a property name but before the colon.
-      if (comment = scanner.scan(Sass::SCSS::RX::COMMENT))
+      if comment = scanner.scan(Sass::SCSS::RX::COMMENT)
         res << comment
-        offset += comment.length
       end
 
       name = line.text[0...scanner.pos]
-      if (scanned = scanner.scan(/\s*:(?:\s+|$)/)) # test for a property
-        offset += scanned.length
-        property = parse_property(name, res, scanner.rest, :new, line, offset)
-        property.name_source_range = ident_range
-        property
+      if scanner.scan(/\s*:(?:\s|$)/)
+        parse_property(name, res, scanner.rest, :new, line)
       else
         res.pop if comment
-
-        if (trailing = (scanner.scan(/\s*#{Sass::SCSS::RX::COMMENT}/) ||
-                        scanner.scan(/\s*#{Sass::SCSS::RX::SINGLE_LINE_COMMENT}/)))
-          trailing.strip!
-        end
-        interp_parsed = parse_interp(scanner.rest)
-        selector_range = Sass::Source::Range.new(
-          ident_range.start_pos,
-          Sass::Source::Position.new(@line, to_parser_offset(line.offset) + line.text.length),
-          @options[:filename], @options[:importer])
-        rule = Tree::RuleNode.new(res + interp_parsed, selector_range)
-        rule << Tree::CommentNode.new([trailing], :silent) if trailing
-        rule
+        Tree::RuleNode.new(res + parse_interp(scanner.rest))
       end
     end
 
-    # @comment
-    #   rubocop:disable ParameterLists
-    def parse_property(name, parsed_name, value, prop, line, start_offset)
-      # rubocop:enable ParameterLists
+    def parse_property(name, parsed_name, value, prop, line)
       if value.strip.empty?
-        expr = Sass::Script::Tree::Literal.new(Sass::Script::Value::String.new(""))
-        end_offset = start_offset
+        expr = Sass::Script::String.new("")
       else
-        expr = parse_script(value, :offset => to_parser_offset(start_offset))
-        end_offset = expr.source_range.end_pos.offset - 1
+        expr = parse_script(value, :offset => line.offset + line.text.index(value))
       end
       node = Tree::PropNode.new(parse_interp(name), expr, prop)
-      node.value_source_range = Sass::Source::Range.new(
-        Sass::Source::Position.new(line.index, to_parser_offset(start_offset)),
-        Sass::Source::Position.new(line.index, to_parser_offset(end_offset)),
-        @options[:filename], @options[:importer])
       if value.strip.empty? && line.children.empty?
         raise SyntaxError.new(
           "Invalid property: \"#{node.declaration}\" (no value)." +
@@ -725,24 +618,15 @@ WARNING
     end
 
     def parse_variable(line)
-      name, value, flags = line.text.scan(Script::MATCH)[0]
+      name, value, default = line.text.scan(Script::MATCH)[0]
       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
-      flags = flags ? flags.split(/\s+/) : []
-      if (invalid_flag = flags.find {|f| f != '!default' && f != '!global'})
-        raise SyntaxError.new("Invalid flag \"#{invalid_flag}\".", :line => @line)
-      end
 
-      # This workaround is needed for the case when the variable value is part of the identifier,
-      # otherwise we end up with the offset equal to the value index inside the name:
-      # $red_color: red;
-      var_lhs_length = 1 + name.length # 1 stands for '$'
-      index = line.text.index(value, line.offset + var_lhs_length) || 0
-      expr = parse_script(value, :offset => to_parser_offset(line.offset + index))
+      expr = parse_script(value, :offset => line.offset + line.text.index(value))
 
-      Tree::VariableNode.new(name, expr, flags.include?('!default'), flags.include?('!global'))
+      Tree::VariableNode.new(name, expr, default)
     end
 
     def parse_comment(line)
@@ -752,171 +636,108 @@ WARNING
         if silent
           value = [line.text]
         else
-          value = self.class.parse_interp(
-            line.text, line.index, to_parser_offset(line.offset), :filename => @filename)
+          value = self.class.parse_interp(line.text, line.index, line.offset, :filename => @filename)
         end
-        value = Sass::Util.with_extracted_values(value) do |str|
+        value = with_extracted_values(value) do |str|
           str = str.gsub(/^#{line.comment_tab_str}/m, '')[2..-1] # get rid of // or /*
           format_comment_text(str, silent)
         end
-        type = if silent
-                 :silent
-               elsif loud
-                 :loud
-               else
-                 :normal
-               end
+        type = if silent then :silent elsif loud then :loud else :normal end
         Tree::CommentNode.new(value, type)
       else
-        Tree::RuleNode.new(parse_interp(line.text), full_line_range(line))
+        Tree::RuleNode.new(parse_interp(line.text))
       end
     end
 
-    DIRECTIVES = Set[:mixin, :include, :function, :return, :debug, :warn, :for,
-      :each, :while, :if, :else, :extend, :import, :media, :charset, :content,
-      :at_root, :error]
-
-    # @comment
-    #   rubocop:disable MethodLength
     def parse_directive(parent, line, root)
       directive, whitespace, value = line.text[1..-1].split(/(\s+)/, 2)
-      raise SyntaxError.new("Invalid directive: '@'.") unless directive
       offset = directive.size + whitespace.size + 1 if whitespace
 
-      directive_name = directive.gsub('-', '_').to_sym
-      if DIRECTIVES.include?(directive_name)
-        return send("parse_#{directive_name}_directive", parent, line, root, value, offset)
-      end
-
-      unprefixed_directive = directive.gsub(/^-[a-z0-9]+-/i, '')
-      if unprefixed_directive == 'supports'
+      # If value begins with url( or ",
+      # it's a CSS @import rule and we don't want to touch it.
+      case directive
+      when 'import'
+        parse_import(line, value, offset)
+      when 'mixin'
+        parse_mixin_definition(line)
+      when 'content'
+        parse_content_directive(line)
+      when 'include'
+        parse_mixin_include(line, root)
+      when 'function'
+        parse_function(line, root)
+      when 'for'
+        parse_for(line, root, value)
+      when 'each'
+        parse_each(line, root, value)
+      when 'else'
+        parse_else(parent, line, value)
+      when 'while'
+        raise SyntaxError.new("Invalid while directive '@while': expected expression.") unless value
+        Tree::WhileNode.new(parse_script(value, :offset => offset))
+      when 'if'
+        raise SyntaxError.new("Invalid if directive '@if': expected expression.") unless value
+        Tree::IfNode.new(parse_script(value, :offset => offset))
+      when '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))
+      when '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?
+        optional = !!value.gsub!(/\s+#{Sass::SCSS::RX::OPTIONAL}$/, '')
+        offset = line.offset + line.text.index(value).to_i
+        Tree::ExtendNode.new(parse_interp(value, offset), optional)
+      when '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))
+      when 'return'
+        raise SyntaxError.new("Invalid @return: expected expression.") unless value
+        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath return directives.",
+          :line => @line + 1) unless line.children.empty?
+        offset = line.offset + line.text.index(value).to_i
+        Tree::ReturnNode.new(parse_script(value, :offset => offset))
+      when '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)
+      when 'media'
         parser = Sass::SCSS::Parser.new(value, @options[:filename], @line)
-        return Tree::SupportsNode.new(directive, parser.parse_supports_condition)
-      end
-
-      Tree::DirectiveNode.new(
-        value.nil? ? ["@#{directive}"] : ["@#{directive} "] + parse_interp(value, offset))
-    end
-
-    def parse_while_directive(parent, line, root, value, offset)
-      raise SyntaxError.new("Invalid while directive '@while': expected expression.") unless value
-      Tree::WhileNode.new(parse_script(value, :offset => offset))
-    end
-
-    def parse_if_directive(parent, line, root, value, offset)
-      raise SyntaxError.new("Invalid if directive '@if': expected expression.") unless value
-      Tree::IfNode.new(parse_script(value, :offset => offset))
-    end
-
-    def parse_debug_directive(parent, line, root, value, offset)
-      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))
-    end
-
-    def parse_error_directive(parent, line, root, value, offset)
-      raise SyntaxError.new("Invalid error directive '@error': expected expression.") unless value
-      raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath error directives.",
-        :line => @line + 1) unless line.children.empty?
-      offset = line.offset + line.text.index(value).to_i
-      Tree::ErrorNode.new(parse_script(value, :offset => offset))
-    end
-
-    def parse_extend_directive(parent, line, root, value, offset)
-      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?
-      optional = !!value.gsub!(/\s+#{Sass::SCSS::RX::OPTIONAL}$/, '')
-      offset = line.offset + line.text.index(value).to_i
-      interp_parsed = parse_interp(value, offset)
-      selector_range = Sass::Source::Range.new(
-        Sass::Source::Position.new(@line, to_parser_offset(offset)),
-        Sass::Source::Position.new(@line, to_parser_offset(line.offset) + line.text.length),
-        @options[:filename], @options[:importer]
-      )
-      Tree::ExtendNode.new(interp_parsed, optional, selector_range)
-    end
-    # @comment
-    #   rubocop:enable MethodLength
-
-    def parse_warn_directive(parent, line, root, value, offset)
-      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))
-    end
-
-    def parse_return_directive(parent, line, root, value, offset)
-      raise SyntaxError.new("Invalid @return: expected expression.") unless value
-      raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath return directives.",
-        :line => @line + 1) unless line.children.empty?
-      offset = line.offset + line.text.index(value).to_i
-      Tree::ReturnNode.new(parse_script(value, :offset => offset))
-    end
-
-    def parse_charset_directive(parent, line, root, value, offset)
-      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)
-    end
-
-    def parse_media_directive(parent, line, root, value, offset)
-      parser = Sass::SCSS::Parser.new(value,
-        @options[:filename], @options[:importer],
-        @line, to_parser_offset(@offset))
-      offset = line.offset + line.text.index('media').to_i - 1
-      parsed_media_query_list = parser.parse_media_query_list.to_a
-      node = Tree::MediaNode.new(parsed_media_query_list)
-      node.source_range = Sass::Source::Range.new(
-        Sass::Source::Position.new(@line, to_parser_offset(offset)),
-        Sass::Source::Position.new(@line, to_parser_offset(line.offset) + line.text.length),
-        @options[:filename], @options[:importer])
-      node
-    end
-
-    def parse_at_root_directive(parent, line, root, value, offset)
-      return Sass::Tree::AtRootNode.new unless value
+        Tree::MediaNode.new(parser.parse_media_query_list.to_a)
+      when nil
+        raise SyntaxError.new("Invalid directive: '@'.")
+      else
+        unprefixed_directive = directive.gsub(/^-[a-z0-9]+-/i, '')
+        if unprefixed_directive == 'supports'
+          parser = Sass::SCSS::Parser.new(value, @options[:filename], @line)
+          return Tree::SupportsNode.new(directive, parser.parse_supports_condition)
+        end
 
-      if value.start_with?('(')
-        parser = Sass::SCSS::Parser.new(value,
-          @options[:filename], @options[:importer],
-          @line, to_parser_offset(@offset))
-        offset = line.offset + line.text.index('at-root').to_i - 1
-        return Tree::AtRootNode.new(parser.parse_at_root_query)
+        Tree::DirectiveNode.new(
+          value.nil? ? ["@#{directive}"] : ["@#{directive} "] + parse_interp(value, offset))
       end
-
-      at_root_node = Tree::AtRootNode.new
-      parsed = parse_interp(value, offset)
-      rule_node = Tree::RuleNode.new(parsed, full_line_range(line))
-
-      # The caller expects to automatically add children to the returned node
-      # and we want it to add children to the rule node instead, so we
-      # manually handle the wiring here and return nil so the caller doesn't
-      # duplicate our efforts.
-      append_children(rule_node, line.children, false)
-      at_root_node << rule_node
-      parent << at_root_node
-      nil
     end
 
-    def parse_for_directive(parent, line, root, value, offset)
-      var, from_expr, to_name, to_expr =
-        value.scan(/^([^\s]+)\s+from\s+(.+)\s+(to|through)\s+(.+)$/).first
+    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 value !~ /^[^\s]+/
+        if text !~ /^[^\s]+/
           expected = "variable name"
-        elsif value !~ /^[^\s]+\s+from\s+.+/
+        elsif text !~ /^[^\s]+\s+from\s+.+/
           expected = "'from <expr>'"
         else
           expected = "'to <expr>' or 'through <expr>'"
         end
-        raise SyntaxError.new("Invalid for directive '@for #{value}': expected #{expected}.")
+        raise SyntaxError.new("Invalid for directive '@for #{text}': expected #{expected}.")
       end
       raise SyntaxError.new("Invalid variable \"#{var}\".") unless var =~ Script::VALIDATE
 
@@ -926,35 +747,31 @@ WARNING
       Tree::ForNode.new(var, parsed_from, parsed_to, to_name == 'to')
     end
 
-    def parse_each_directive(parent, line, root, value, offset)
-      vars, list_expr = value.scan(/^([^\s]+(?:\s*,\s*[^\s]+)*)\s+in\s+(.+)$/).first
+    def parse_each(line, root, text)
+      var, list_expr = text.scan(/^([^\s]+)\s+in\s+(.+)$/).first
 
-      if vars.nil? # scan failed, try to figure out why for error message
-        if value !~ /^[^\s]+/
+      if var.nil? # scan failed, try to figure out why for error message
+        if text !~ /^[^\s]+/
           expected = "variable name"
-        elsif value !~ /^[^\s]+(?:\s*,\s*[^\s]+)*[^\s]+\s+from\s+.+/
+        elsif text !~ /^[^\s]+\s+from\s+.+/
           expected = "'in <expr>'"
         end
-        raise SyntaxError.new("Invalid each directive '@each #{value}': expected #{expected}.")
-      end
-
-      vars = vars.split(',').map do |var|
-        var.strip!
-        raise SyntaxError.new("Invalid variable \"#{var}\".") unless var =~ Script::VALIDATE
-        var[1..-1]
+        raise SyntaxError.new("Invalid for directive '@each #{text}': expected #{expected}.")
       end
+      raise SyntaxError.new("Invalid variable \"#{var}\".") unless var =~ Script::VALIDATE
 
+      var = var[1..-1]
       parsed_list = parse_script(list_expr, :offset => line.offset + line.text.index(list_expr))
-      Tree::EachNode.new(vars, parsed_list)
+      Tree::EachNode.new(var, parsed_list)
     end
 
-    def parse_else_directive(parent, line, root, value, offset)
+    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 value
-        if value !~ /^if\s+(.+)/
-          raise SyntaxError.new("Invalid else directive '@else #{value}': expected 'if <expr>'.")
+      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
@@ -965,7 +782,7 @@ WARNING
       nil
     end
 
-    def parse_import_directive(parent, line, root, value, offset)
+    def parse_import(line, value, offset)
       raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath import directives.",
         :line => @line + 1) unless line.children.empty?
 
@@ -973,9 +790,8 @@ WARNING
       values = []
 
       loop do
-        unless (node = parse_import_arg(scanner, offset + scanner.pos))
-          raise SyntaxError.new(
-            "Invalid @import: expected file to import, was #{scanner.rest.inspect}",
+        unless node = parse_import_arg(scanner, offset + scanner.pos)
+          raise SyntaxError.new("Invalid @import: expected file to import, was #{scanner.rest.inspect}",
             :line => @line)
         end
         values << node
@@ -987,81 +803,35 @@ WARNING
           :line => @line)
       end
 
-      values
+      return values
     end
 
-    # @comment
-    #   rubocop:disable MethodLength
     def parse_import_arg(scanner, offset)
       return if scanner.eos?
 
       if scanner.match?(/url\(/i)
-        script_parser = Sass::Script::Parser.new(scanner, @line, to_parser_offset(offset), @options)
+        script_parser = Sass::Script::Parser.new(scanner, @line, offset, @options)
         str = script_parser.parse_string
-
-        if scanner.eos?
-          end_pos = str.source_range.end_pos
-          node = Tree::CssImportNode.new(str)
-        else
-          media_parser = Sass::SCSS::Parser.new(scanner,
-            @options[:filename], @options[:importer],
-            @line, str.source_range.end_pos.offset)
-          media = media_parser.parse_media_query_list
-          end_pos = Sass::Source::Position.new(@line, media_parser.offset + 1)
-          node = Tree::CssImportNode.new(str, media.to_a)
-        end
-
-        node.source_range = Sass::Source::Range.new(
-          str.source_range.start_pos, end_pos,
-          @options[:filename], @options[:importer])
-        return node
+        media_parser = Sass::SCSS::Parser.new(scanner, @options[:filename], @line)
+        media = media_parser.parse_media_query_list
+        return Tree::CssImportNode.new(str, media.to_a)
       end
 
-      unless (quoted_val = scanner.scan(Sass::SCSS::RX::STRING))
-        scanned = scanner.scan(/[^,;]+/)
-        node = Tree::ImportNode.new(scanned)
-        start_parser_offset = to_parser_offset(offset)
-        node.source_range = Sass::Source::Range.new(
-          Sass::Source::Position.new(@line, start_parser_offset),
-          Sass::Source::Position.new(@line, start_parser_offset + scanned.length),
-          @options[:filename], @options[:importer])
-        return node
+      unless str = scanner.scan(Sass::SCSS::RX::STRING)
+        return Tree::ImportNode.new(scanner.scan(/[^,;]+/))
       end
 
-      start_offset = offset
-      offset += scanner.matched.length
-      val = Sass::Script::Value::String.value(scanner[1] || scanner[2])
-      scanned = scanner.scan(/\s*/)
+      val = scanner[1] || scanner[2]
+      scanner.scan(/\s*/)
       if !scanner.match?(/[,;]|$/)
-        offset += scanned.length if scanned
-        media_parser = Sass::SCSS::Parser.new(scanner,
-          @options[:filename], @options[:importer], @line, offset)
+        media_parser = Sass::SCSS::Parser.new(scanner, @options[:filename], @line)
         media = media_parser.parse_media_query_list
-        node = Tree::CssImportNode.new(quoted_val, media.to_a)
-        node.source_range = Sass::Source::Range.new(
-          Sass::Source::Position.new(@line, to_parser_offset(start_offset)),
-          Sass::Source::Position.new(@line, media_parser.offset),
-          @options[:filename], @options[:importer])
-      elsif val =~ %r{^(https?:)?//}
-        node = Tree::CssImportNode.new(quoted_val)
-        node.source_range = Sass::Source::Range.new(
-          Sass::Source::Position.new(@line, to_parser_offset(start_offset)),
-          Sass::Source::Position.new(@line, to_parser_offset(offset)),
-          @options[:filename], @options[:importer])
+        Tree::CssImportNode.new(str || uri, media.to_a)
+      elsif val =~ /^(https?:)?\/\//
+        Tree::CssImportNode.new("url(#{val})")
       else
-        node = Tree::ImportNode.new(val)
-        node.source_range = Sass::Source::Range.new(
-          Sass::Source::Position.new(@line, to_parser_offset(start_offset)),
-          Sass::Source::Position.new(@line, to_parser_offset(offset)),
-          @options[:filename], @options[:importer])
+        Tree::ImportNode.new(val)
       end
-      node
-    end
-    # @comment
-    #   rubocop:enable MethodLength
-
-    def parse_mixin_directive(parent, line, root, value, offset)
-      parse_mixin_definition(line)
     end
 
     MIXIN_DEF_RE = /^(?:=|@mixin)\s*(#{Sass::SCSS::RX::IDENT})(.*)$/
@@ -1070,53 +840,45 @@ WARNING
       raise SyntaxError.new("Invalid mixin \"#{line.text[1..-1]}\".") if name.nil?
 
       offset = line.offset + line.text.size - arg_string.size
-      args, splat = Script::Parser.new(arg_string.strip, @line, to_parser_offset(offset), @options).
+      args, splat = Script::Parser.new(arg_string.strip, @line, offset, @options).
         parse_mixin_definition_arglist
       Tree::MixinDefNode.new(name, args, splat)
     end
 
     CONTENT_RE = /^@content\s*(.+)?$/
-    def parse_content_directive(parent, line, root, value, offset)
+    def parse_content_directive(line)
       trailing = line.text.scan(CONTENT_RE).first.first
-      unless trailing.nil?
-        raise SyntaxError.new(
-          "Invalid content directive. Trailing characters found: \"#{trailing}\".")
-      end
+      raise SyntaxError.new("Invalid content directive. Trailing characters found: \"#{trailing}\".") unless trailing.nil?
       raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath @content directives.",
         :line => line.index + 1) unless line.children.empty?
       Tree::ContentNode.new
     end
 
-    def parse_include_directive(parent, line, root, value, offset)
-      parse_mixin_include(line, root)
-    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, keywords, splat, kwarg_splat =
-        Script::Parser.new(arg_string.strip, @line, to_parser_offset(offset), @options).
-          parse_mixin_include_arglist
-      Tree::MixinNode.new(name, args, keywords, splat, kwarg_splat)
+      args, keywords, splat = Script::Parser.new(arg_string.strip, @line, offset, @options).
+        parse_mixin_include_arglist
+      Tree::MixinNode.new(name, args, keywords, splat)
     end
 
     FUNCTION_RE = /^@function\s*(#{Sass::SCSS::RX::IDENT})(.*)$/
-    def parse_function_directive(parent, line, root, value, offset)
+    def parse_function(line, root)
       name, arg_string = line.text.scan(FUNCTION_RE).first
       raise SyntaxError.new("Invalid function definition \"#{line.text}\".") if name.nil?
 
       offset = line.offset + line.text.size - arg_string.size
-      args, splat = Script::Parser.new(arg_string.strip, @line, to_parser_offset(offset), @options).
+      args, splat = Script::Parser.new(arg_string.strip, @line, offset, @options).
         parse_function_definition_arglist
       Tree::FunctionNode.new(name, args, splat)
     end
 
     def parse_script(script, options = {})
       line = options[:line] || @line
-      offset = options[:offset] || @offset + 1
+      offset = options[:offset] || 0
       Script.parse(script, line, offset, @options)
     end
 
@@ -1128,12 +890,12 @@ WARNING
         content.shift
       end
 
-      return "/* */" if content.empty?
-      content.last.gsub!(/ ?\*\/ *$/, '')
+      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 *") + " */"
+        "//" + content.join("\n//")
       else
         # The #gsub fixes the case of a trailing */
         "/*" + content.join("\n *").gsub(/ \*\Z/, '') + " */"
@@ -1144,20 +906,8 @@ WARNING
       self.class.parse_interp(text, @line, offset, :filename => @filename)
     end
 
-    # Parser tracks 1-based line and offset, so our offset should be converted.
-    def to_parser_offset(offset)
-      offset + 1
-    end
-
-    def full_line_range(line)
-      Sass::Source::Range.new(
-        Sass::Source::Position.new(@line, to_parser_offset(line.offset)),
-        Sass::Source::Position.new(@line, to_parser_offset(line.offset) + line.text.length),
-        @options[:filename], @options[:importer])
-    end
-
     # It's important that this have strings (at least)
-    # at the beginning, the end, and between each Script::Tree::Node.
+    # at the beginning, the end, and between each Script::Node.
     #
     # @private
     def self.parse_interp(text, line, offset, options)
@@ -1165,13 +915,12 @@ WARNING
       rest = Sass::Shared.handle_interpolation text do |scan|
         escapes = scan[2].size
         res << scan.matched[0...-2 - escapes]
-        if escapes.odd?
+        if escapes % 2 == 1
           res << "\\" * (escapes - 1) << '#{'
         else
           res << "\\" * [0, escapes - 1].max
-          # Add 1 to emulate to_parser_offset.
           res << Script::Parser.new(
-            scan, line, offset + scan.pos - scan.matched_size + 1, options).
+            scan, line, offset + scan.pos - scan.matched_size, options).
             parse_interpolated
         end
       end