sass 3.3.0.alpha.149 → 3.3.0.alpha.162

data/lib/sass/script/lexer.rb

@@ -16,26 +16,29 @@ module Sass
       # `value`: \[`Object`\]
       # : The Ruby object corresponding to the value of the token.
       #
-      # `line`: \[`Fixnum`\]
-      # : The line of the source file on which the token appears (1-based).
-      #
-      # `offset`: \[`Fixnum`\]
-      # : The number of characters into the line the SassScript token appeared (1-based).
+      # `source_range`: [`Sass::Source::Range`\]
+      # : The range in the source file in which the token appeared.
       #
       # `pos`: \[`Fixnum`\]
       # : The scanner position at which the SassScript token appeared.
-      Token = Struct.new(:type, :value, :line, :offset, :pos)
+      Token = Struct.new(:type, :value, :source_range, :pos)
 
       # The line number of the lexer's current position.
       #
       # @return [Fixnum]
-      attr_reader :line
+      def line
+        return @line unless @tok
+        @tok.source_range.start_pos.line
+      end
 
       # The number of bytes into the current line
       # of the lexer's current position (1-based).
       #
       # @return [Fixnum]
-      attr_reader :offset
+      def offset
+        return @offset unless @tok
+        @tok.source_range.start_pos.offset
+      end
 
       # A hash from operator strings to the corresponding token types.
       OPERATORS = {
@@ -174,8 +177,8 @@ module Sass
       def unpeek!
         if @tok
           @scanner.pos = @tok.pos
-          @line = @tok.line
-          @offset = @tok.offset
+          @line = @tok.source_range.start_pos.line
+          @offset = @tok.source_range.start_pos.offset
         end
       end
 
@@ -219,12 +222,11 @@ module Sass
 
       def read_token
         return if done?
+        start_pos = source_position
+        start_index = @scanner.pos
         return unless value = token
-        type, val, size = value
-        size ||= @scanner.matched_size
-
-        val.line = @line if val.is_a?(Script::Node)
-        Token.new(type, val, @line, @offset - size, @scanner.pos - size)
+        type, val = value
+        Token.new(type, val, range(start_pos), @scanner.pos - @scanner.matched_size)
       end
 
       def whitespace
@@ -259,7 +261,6 @@ module Sass
       end
 
       def string(re, open)
-        start_pos = source_position
         return unless scan(STRING_REGULAR_EXPRESSIONS[[re, open]])
         if @scanner[2] == '#{' #'
           @scanner.pos -= 2 # Don't actually consume the #{
@@ -268,50 +269,41 @@ module Sass
         end
         str =
           if re == :uri
-            Script::String.new("#{'url(' unless open}#{@scanner[1]}#{')' unless @scanner[2] == '#{'}")
+            Script::Value::String.new("#{'url(' unless open}#{@scanner[1]}#{')' unless @scanner[2] == '#{'}")
           else
-            Script::String.new(@scanner[1].gsub(/\\(['"]|\#\{)/, '\1'), :string)
+            Script::Value::String.new(@scanner[1].gsub(/\\(['"]|\#\{)/, '\1'), :string)
           end
-        str.source_range = range(start_pos)
         [:string, str]
       end
 
       def number
-        start_pos = source_position
         return unless scan(REGULAR_EXPRESSIONS[:number])
         value = @scanner[2] ? @scanner[2].to_f : @scanner[3].to_i
         value = -value if @scanner[1]
-        script_number = Script::Number.new(value, Array(@scanner[4]))
-        script_number.source_range = range(start_pos)
+        script_number = Script::Value::Number.new(value, Array(@scanner[4]))
         [:number, script_number]
       end
 
       def color
-        start_pos = source_position
         return unless s = scan(REGULAR_EXPRESSIONS[:color])
         raise Sass::SyntaxError.new(<<MESSAGE.rstrip) unless s.size == 4 || s.size == 7
 Colors must have either three or six digits: '#{s}'
 MESSAGE
         value = s.scan(/^#(..?)(..?)(..?)$/).first.
           map {|num| num.ljust(2, num).to_i(16)}
-        script_color = Script::Color.new(value)
-        script_color.source_range = range(start_pos)
+        script_color = Script::Value::Color.new(value)
         [:color, script_color]
       end
 
       def bool
-        start_pos = source_position
         return unless s = scan(REGULAR_EXPRESSIONS[:bool])
-        script_bool = Script::Bool.new(s == 'true')
-        script_bool.source_range = range(start_pos)
+        script_bool = Script::Value::Bool.new(s == 'true')
         [:bool, script_bool]
       end
 
       def null
-        start_pos = source_position
         return unless scan(REGULAR_EXPRESSIONS[:null])
-        script_null = Script::Null.new
-        script_null.source_range = range(start_pos)
+        script_null = Script::Value::Null.new
         [:null, script_null]
       end
 
@@ -331,7 +323,7 @@ MESSAGE
 
       def special_val
         return unless scan(/!important/i)
-        [:string, Script::String.new("!important")]
+        [:string, Script::Value::String.new("!important")]
       end
 
       def ident_op

data/lib/sass/script/parser.rb

@@ -3,7 +3,7 @@ require 'sass/script/lexer'
 module Sass
   module Script
     # The parser for SassScript.
-    # It parses a string of code into a tree of {Script::Node}s.
+    # It parses a string of code into a tree of {Script::Tree::Node}s.
     class Parser
       # The line number of the parser's current position.
       #
@@ -36,14 +36,12 @@ module Sass
       # which signals the end of an interpolated segment,
       # it returns rather than throwing an error.
       #
-      # @return [Script::Node] The root node of the parse tree
+      # @return [Script::Tree::Node] The root node of the parse tree
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
       def parse_interpolated
-        start_pos = source_position
         expr = assert_expr :expr
         assert_tok :end_interpolation
         expr.options = @options
-        expr.source_range = range(start_pos)
         expr
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -52,14 +50,12 @@ module Sass
 
       # Parses a SassScript expression.
       #
-      # @return [Script::Node] The root node of the parse tree
+      # @return [Script::Tree::Node] The root node of the parse tree
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
       def parse
-        start_pos = source_position
         expr = assert_expr :expr
         assert_done
         expr.options = @options
-        expr.source_range = range(start_pos)
         expr
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -70,7 +66,7 @@ module Sass
       # ending it when it encounters one of the given identifier tokens.
       #
       # @param [#include?(String)] A set of strings that delimit the expression.
-      # @return [Script::Node] The root node of the parse tree
+      # @return [Script::Tree::Node] The root node of the parse tree
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
       def parse_until(tokens)
         @stop_at = tokens
@@ -85,7 +81,7 @@ module Sass
 
       # Parses the argument list for a mixin include.
       #
-      # @return [(Array<Script::Node>, {String => Script::Node}, Script::Node)]
+      # @return [(Array<Script::Tree::Node>, {String => Script::Tree::Node}, Script::Tree::Node)]
       #   The root nodes of the positional arguments, keyword arguments, and
       #   splat argument. Keyword arguments are in a hash from names to values.
       # @raise [Sass::SyntaxError] if the argument list isn't valid SassScript
@@ -108,7 +104,7 @@ module Sass
 
       # Parses the argument list for a mixin definition.
       #
-      # @return [(Array<Script::Node>, Script::Node)]
+      # @return [(Array<Script::Tree::Node>, Script::Tree::Node)]
       #   The root nodes of the arguments, and the splat argument.
       # @raise [Sass::SyntaxError] if the argument list isn't valid SassScript
       def parse_mixin_definition_arglist
@@ -128,7 +124,7 @@ module Sass
 
       # Parses the argument list for a function definition.
       #
-      # @return [(Array<Script::Node>, Script::Node)]
+      # @return [(Array<Script::Tree::Node>, Script::Tree::Node)]
       #   The root nodes of the arguments, and the splat argument.
       # @raise [Sass::SyntaxError] if the argument list isn't valid SassScript
       def parse_function_definition_arglist
@@ -149,7 +145,7 @@ module Sass
       # Parse a single string value, possibly containing interpolation.
       # Doesn't assert that the scanner is finished after parsing.
       #
-      # @return [Script::Node] The root node of the parse tree.
+      # @return [Script::Tree::Node] The root node of the parse tree.
       # @raise [Sass::SyntaxError] if the string isn't valid SassScript
       def parse_string
         unless (peek = @lexer.peek) &&
@@ -170,7 +166,7 @@ module Sass
       # Parses a SassScript expression.
       #
       # @overload parse(str, line, offset, filename = nil)
-      # @return [Script::Node] The root node of the parse tree
+      # @return [Script::Tree::Node] The root node of the parse tree
       # @see Parser#initialize
       # @see Parser#parse
       def self.parse(*args)
@@ -225,9 +221,7 @@ module Sass
                 end
 
                 start_pos = source_position
-                e = Operation.new(e, assert_expr(#{sub.inspect}), tok.type)
-                e.line = start_pos.line
-                e.source_range = range(start_pos)
+                e = node(Tree::Operation.new(e, assert_expr(#{sub.inspect}), tok.type), start_pos)
               end
               e
             end
@@ -239,10 +233,8 @@ RUBY
             def unary_#{op}
               return #{sub} unless tok = try_tok(:#{op})
               interp = try_op_before_interp(tok) and return interp
-              line = @lexer.line 
-              op = UnaryOperation.new(assert_expr(:unary_#{op}), :#{op})
-              op.line = line
-              op
+              start_pos = source_position
+              node(Tree::UnaryOperation.new(assert_expr(:unary_#{op}), :#{op}), start_pos)
             end
 RUBY
         end
@@ -254,10 +246,6 @@ RUBY
         Sass::Source::Position.new(line, offset)
       end
 
-      def token_start_position(token)
-        Sass::Source::Position.new(token.line, token.offset)
-      end
-
       def range(start_pos, end_pos=source_position)
         Sass::Source::Range.new(start_pos, end_pos, @options[:filename], @options[:importer])
       end
@@ -269,15 +257,15 @@ RUBY
         interp = try_ops_after_interp([:comma], :expr) and return interp
         start_pos = source_position
         return unless e = interpolation
-        list = node(List.new([e], :comma), start_pos)
+        list = node(Sass::Script::Tree::ListLiteral.new([e], :comma), start_pos)
         while tok = try_tok(:comma)
           if interp = try_op_before_interp(tok, list)
             return interp unless other_interp = try_ops_after_interp([:comma], :expr, interp)
             return other_interp
           end
-          list.value << assert_expr(:interpolation)
+          list.elements << assert_expr(:interpolation)
         end
-        list.value.size == 1 ? list.value.first : list
+        list.elements.size == 1 ? list.elements.first : list
       end
 
       production :equals, :interpolation, :single_eq
@@ -285,10 +273,10 @@ RUBY
       def try_op_before_interp(op, prev = nil)
         return unless @lexer.peek && @lexer.peek.type == :begin_interpolation
         wb = @lexer.whitespace?(op)
-        str = Script::String.new(Lexer::OPERATORS_REVERSE[op.type])
-        str.line = @lexer.line
-        interp = Script::Interpolation.new(prev, str, nil, wb, !:wa, :originally_text)
-        interp.line = @lexer.line
+        str = literal_node(Script::Value::String.new(Lexer::OPERATORS_REVERSE[op.type]), op.source_range)
+        interp = node(
+          Script::Tree::Interpolation.new(prev, str, nil, wb, !:wa, :originally_text),
+          (prev || str).source_range.start_pos)
         interpolation(interp)
       end
 
@@ -298,12 +286,11 @@ RUBY
         interp = try_op_before_interp(op, prev) and return interp
 
         wa = @lexer.whitespace?
-        str = Script::String.new(Lexer::OPERATORS_REVERSE[op.type])
+        str = literal_node(Script::Value::String.new(Lexer::OPERATORS_REVERSE[op.type]), op.source_range)
         str.line = @lexer.line
-        start_pos = source_position
-        interp = Script::Interpolation.new(prev, str, assert_expr(name), !:wb, wa, :originally_text)
-        interp.line = @lexer.line
-        interp.source_range = range(start_pos)
+        interp = node(
+          Script::Tree::Interpolation.new(prev, str, assert_expr(name), !:wb, wa, :originally_text),
+          (prev || str).source_range.start_pos)
         return interp
       end
 
@@ -314,8 +301,9 @@ RUBY
           line = @lexer.line
           mid = parse_interpolated
           wa = @lexer.whitespace?
-          e = Script::Interpolation.new(e, mid, space, wb, wa)
-          e.line = line
+          e = node(
+            Script::Tree::Interpolation.new(e, mid, space, wb, wa),
+            (e || mid).source_range.start_pos)
         end
         e
       end
@@ -327,7 +315,7 @@ RUBY
         while e = or_expr
           arr << e
         end
-        arr.size == 1 ? arr.first : node(List.new(arr, :space), start_pos)
+        arr.size == 1 ? arr.first : node(Sass::Script::Tree::ListLiteral.new(arr, :space), start_pos)
       end
 
       production :or_expr, :and_expr, :or
@@ -347,17 +335,18 @@ RUBY
         return if @stop_at && @stop_at.include?(@lexer.peek.value)
 
         name = @lexer.next
-        if color = Color::COLOR_NAMES[name.value.downcase]
-          return node(Color.new(color), token_start_position(name), source_position)
+        if color = Sass::Script::Value::Color::COLOR_NAMES[name.value.downcase]
+          return literal_node(Sass::Script::Value::Color.new(color), name.source_range)
         end
-        node(Script::String.new(name.value, :identifier), token_start_position(name), source_position)
+        literal_node(Script::Value::String.new(name.value, :identifier), name.source_range)
       end
 
       def funcall
         return raw unless tok = try_tok(:funcall)
         args, keywords, splat = fn_arglist || [[], {}]
         assert_tok(:rparen)
-        node(Script::Funcall.new(tok.value, args, keywords, splat), token_start_position(tok), source_position)
+        node(Script::Tree::Funcall.new(tok.value, args, keywords, splat),
+          tok.source_range.start_pos, source_position)
       end
 
       def defn_arglist!(must_have_parens)
@@ -373,8 +362,7 @@ RUBY
         must_have_default = false
         loop do
           c = assert_tok(:const)
-          var = Script::Variable.new(c.value)
-          var.source_range = range(c.offset)
+          var = node(Script::Tree::Variable.new(c.value), c.source_range)
           if try_tok(:colon)
             val = assert_expr(:space)
             must_have_default = true
@@ -407,7 +395,7 @@ RUBY
         loop do
           if @lexer.peek && @lexer.peek.type == :colon
             name = e
-            @lexer.expected!("comma") unless name.is_a?(Variable)
+            @lexer.expected!("comma") unless name.is_a?(Tree::Variable)
             assert_tok(:colon)
             value = assert_expr(subexpr, description)
 
@@ -431,17 +419,26 @@ RUBY
       end
 
       def raw
+        start_pos = source_position
         return special_fun unless tok = try_tok(:raw)
-        node(Script::String.new(tok.value))
+        literal_node(Script::Value::String.new(tok.value), tok.source_range)
       end
 
       def special_fun
+        start_pos = source_position
         return paren unless tok = try_tok(:special_fun)
-        first = node(Script::String.new(tok.value.first))
+        first = literal_node(Script::Value::String.new(tok.value.first),
+          start_pos, start_pos.after(tok.value.first))
         Sass::Util.enum_slice(tok.value[1..-1], 2).inject(first) do |l, (i, r)|
-          Script::Interpolation.new(
-            l, i, r && node(Script::String.new(r)),
-            false, false)
+          end_pos = i.source_range.end_pos
+          end_pos = end_pos.after(r) if r
+          node(
+            Script::Tree::Interpolation.new(
+              l, i,
+              r && literal_node(Script::Value::String.new(r),
+                i.source_range.end_pos, end_pos),
+              false, false),
+            start_pos, end_pos)
         end
       end
 
@@ -451,8 +448,9 @@ RUBY
         @in_parens = true
         start_pos = source_position
         e = expr
+        end_pos = source_position
         assert_tok(:rparen)
-        return e || node(List.new([], :space), start_pos)
+        return e || node(Sass::Script::Tree::ListLiteral.new([], :space), start_pos, end_pos)
       ensure
         @in_parens = was_in_parens
       end
@@ -460,31 +458,27 @@ RUBY
       def variable
         start_pos = source_position
         return string unless c = try_tok(:const)
-        node(Variable.new(*c.value), start_pos, source_position)
+        node(Tree::Variable.new(*c.value), start_pos)
       end
 
       def string
         return number unless first = try_tok(:string)
-        return first.value unless try_tok(:begin_interpolation)
-        start_pos = source_position
-        line = @lexer.line
+        str = literal_node(first.value, first.source_range)
+        return str unless try_tok(:begin_interpolation)
         mid = parse_interpolated
         last = assert_expr(:string)
-        interp = StringInterpolation.new(first.value, mid, last)
-        interp.line = line
-        interp.source_range = range(start_pos)
-        interp
+        node(Tree::StringInterpolation.new(str, mid, last), first.source_range.start_pos)
       end
 
       def number
         return literal unless tok = try_tok(:number)
         num = tok.value
         num.original = num.to_s unless @in_parens
-        num
+        literal_node(num, tok.source_range.start_pos)
       end
 
       def literal
-        (t = try_tok(:color, :bool, :null)) && (return t.value)
+        (t = try_tok(:color, :bool, :null)) && (return literal_node(t.value, t.source_range))
       end
 
       # It would be possible to have unified #assert and #try methods,
@@ -517,10 +511,35 @@ RUBY
         @lexer.expected!(EXPR_NAMES[:default])
       end
 
-      def node(node, start_pos = source_position, end_pos = nil)
-        node.line = start_pos.line
+      # @overload node(value, source_range)
+      #   @param value [Sass::Script::Value::Base]
+      #   @param source_range [Sass::Source::Range]
+      # @overload node(value, start_pos, end_pos = source_position)
+      #   @param value [Sass::Script::Value::Base]
+      #   @param start_pos [Sass::Source::Position]
+      #   @param end_pos [Sass::Source::Position]
+      def literal_node(value, source_range_or_start_pos, end_pos = source_position)
+        node(Sass::Script::Tree::Literal.new(value), source_range_or_start_pos, end_pos)
+      end
+
+      # @overload node(node, source_range)
+      #   @param node [Sass::Script::Tree::Node]
+      #   @param source_range [Sass::Source::Range]
+      # @overload node(node, start_pos, end_pos = source_position)
+      #   @param node [Sass::Script::Tree::Node]
+      #   @param start_pos [Sass::Source::Position]
+      #   @param end_pos [Sass::Source::Position]
+      def node(node, source_range_or_start_pos, end_pos = source_position)
+        source_range =
+          if source_range_or_start_pos.is_a?(Sass::Source::Range)
+            source_range_or_start_pos
+          else
+            range(source_range_or_start_pos, end_pos)
+          end
+
+        node.line = source_range.start_pos.line
+        node.source_range = source_range
         node.filename = @options[:filename]
-        node.source_range = range(start_pos, end_pos) if end_pos
         node
       end
     end