oreorenasass 3.4.4 → 3.4.5

data/lib/sass/script/interpolation.rb

@@ -0,0 +1,79 @@
+module Sass::Script
+  # A SassScript object representing `#{}` interpolation outside a string.
+  #
+  # @see StringInterpolation
+  class Interpolation < Node
+    # Interpolation in a property is of the form `before #{mid} after`.
+    #
+    # @param before [Node] The SassScript before the interpolation
+    # @param mid [Node] The SassScript within the interpolation
+    # @param after [Node] The SassScript after the interpolation
+    # @param wb [Boolean] Whether there was whitespace between `before` and `#{`
+    # @param wa [Boolean] Whether there was whitespace between `}` and `after`
+    # @param originally_text [Boolean]
+    #   Whether the original format of the interpolation was plain text,
+    #   not an interpolation.
+    #   This is used when converting back to SassScript.
+    def initialize(before, mid, after, wb, wa, originally_text = false)
+      @before = before
+      @mid = mid
+      @after = after
+      @whitespace_before = wb
+      @whitespace_after = wa
+      @originally_text = originally_text
+    end
+
+    # @return [String] A human-readable s-expression representation of the interpolation
+    def inspect
+      "(interpolation #{@before.inspect} #{@mid.inspect} #{@after.inspect})"
+    end
+
+    # @see Node#to_sass
+    def to_sass(opts = {})
+      res = ""
+      res << @before.to_sass(opts) if @before
+      res << ' ' if @before && @whitespace_before
+      res << '#{' unless @originally_text
+      res << @mid.to_sass(opts)
+      res << '}' unless @originally_text
+      res << ' ' if @after && @whitespace_after
+      res << @after.to_sass(opts) if @after
+      res
+    end
+
+    # Returns the three components of the interpolation, `before`, `mid`, and `after`.
+    #
+    # @return [Array<Node>]
+    # @see #initialize
+    # @see Node#children
+    def children
+      [@before, @mid, @after].compact
+    end
+
+    # @see Node#deep_copy
+    def deep_copy
+      node = dup
+      node.instance_variable_set('@before', @before.deep_copy) if @before
+      node.instance_variable_set('@mid', @mid.deep_copy)
+      node.instance_variable_set('@after', @after.deep_copy) if @after
+      node
+    end
+
+    protected
+
+    # Evaluates the interpolation.
+    #
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @return [Sass::Script::String] The SassScript string that is the value of the interpolation
+    def _perform(environment)
+      res = ""
+      res << @before.perform(environment).to_s if @before
+      res << " " if @before && @whitespace_before
+      val = @mid.perform(environment)
+      res << (val.is_a?(Sass::Script::String) ? val.value : val.to_s)
+      res << " " if @after && @whitespace_after
+      res << @after.perform(environment).to_s if @after
+      opts(Sass::Script::String.new(res))
+    end
+  end
+end

data/lib/sass/script/lexer.rb

@@ -16,29 +16,26 @@ module Sass
       # `value`: \[`Object`\]
       # : The Ruby object corresponding to the value of the token.
       #
-      # `source_range`: \[`Sass::Source::Range`\]
-      # : The range in the source file in which the token appeared.
+      # `line`: \[`Fixnum`\]
+      # : The line of the source file on which the token appears.
+      #
+      # `offset`: \[`Fixnum`\]
+      # : The number of bytes into the line the SassScript token appeared.
       #
       # `pos`: \[`Fixnum`\]
       # : The scanner position at which the SassScript token appeared.
-      Token = Struct.new(:type, :value, :source_range, :pos)
+      Token = Struct.new(:type, :value, :line, :offset, :pos)
 
       # The line number of the lexer's current position.
       #
       # @return [Fixnum]
-      def line
-        return @line unless @tok
-        @tok.source_range.start_pos.line
-      end
+      attr_reader :line
 
       # The number of bytes into the current line
-      # of the lexer's current position (1-based).
+      # of the lexer's current position.
       #
       # @return [Fixnum]
-      def offset
-        return @offset unless @tok
-        @tok.source_range.start_pos.offset
-      end
+      attr_reader :offset
 
       # A hash from operator strings to the corresponding token types.
       OPERATORS = {
@@ -70,9 +67,10 @@ module Sass
 
       OPERATORS_REVERSE = Sass::Util.map_hash(OPERATORS) {|k, v| [v, k]}
 
-      TOKEN_NAMES = Sass::Util.map_hash(OPERATORS_REVERSE) {|k, v| [k, v.inspect]}.merge(
+      TOKEN_NAMES = Sass::Util.map_hash(OPERATORS_REVERSE) {|k, v| [k, v.inspect]}.merge({
           :const => "variable (e.g. $foo)",
-          :ident => "identifier (e.g. middle)")
+          :ident => "identifier (e.g. middle)"
+        })
 
       # A list of operator strings ordered with longer names first
       # so that `>` and `<` don't clobber `>=` and `<=`.
@@ -82,8 +80,6 @@ module Sass
       # with identifier names.
       IDENT_OP_NAMES = OP_NAMES.select {|k, v| k =~ /^\w+/}
 
-      PARSEABLE_NUMBER = /(?:(\d*\.\d+)|(\d+))(?:[eE]([+-]?\d+))?(#{UNIT})?/
-
       # A hash of regular expressions that are used for tokenizing.
       REGULAR_EXPRESSIONS = {
         :whitespace => /\s+/,
@@ -91,22 +87,16 @@ module Sass
         :single_line_comment => SINGLE_LINE_COMMENT,
         :variable => /(\$)(#{IDENT})/,
         :ident => /(#{IDENT})(\()?/,
-        :number => PARSEABLE_NUMBER,
-        :unary_minus_number => /-#{PARSEABLE_NUMBER}/,
+        :number => /(-)?(?:(\d*\.\d+)|(\d+))([a-zA-Z%]+)?/,
         :color => HEXCOLOR,
-        :id => /##{IDENT}/,
-        :selector => /&/,
-        :ident_op => /(#{Regexp.union(*IDENT_OP_NAMES.map do |s|
-          Regexp.new(Regexp.escape(s) + "(?!#{NMCHAR}|\Z)")
-        end)})/,
-        :op => /(#{Regexp.union(*OP_NAMES)})/,
+        :ident_op => %r{(#{Regexp.union(*IDENT_OP_NAMES.map{|s| Regexp.new(Regexp.escape(s) + "(?!#{NMCHAR}|\Z)")})})},
+        :op => %r{(#{Regexp.union(*OP_NAMES)})},
       }
 
       class << self
         private
-
         def string_re(open, close)
-          /#{open}((?:\\.|\#(?!\{)|[^#{close}\\#])*)(#{close}|#\{)/m
+          /#{open}((?:\\.|\#(?!\{)|[^#{close}\\#])*)(#{close}|#\{)/
         end
       end
 
@@ -142,10 +132,10 @@ module Sass
       }
 
       # @param str [String, StringScanner] The source text to lex
-      # @param line [Fixnum] The 1-based line on which the SassScript appears.
-      #   Used for error reporting and sourcemap building
-      # @param offset [Fixnum] The 1-based character (not byte) offset in the line in the source.
-      #   Used for error reporting and sourcemap building
+      # @param line [Fixnum] The line on which the SassScript appears.
+      #   Used for error reporting
+      # @param offset [Fixnum] The number of characters in on which the SassScript appears.
+      #   Used for error reporting
       # @param options [{Symbol => Object}] An options hash;
       #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
       def initialize(str, line, offset, options)
@@ -164,7 +154,7 @@ module Sass
         @tok ||= read_token
         @tok, tok = nil, @tok
         @prev = tok
-        tok
+        return tok
       end
 
       # Returns whether or not there's whitespace before the next token.
@@ -189,11 +179,7 @@ module Sass
       # Rewinds the underlying StringScanner
       # to before the token returned by \{#peek}.
       def unpeek!
-        if @tok
-          @scanner.pos = @tok.pos
-          @line = @tok.source_range.start_pos.line
-          @offset = @tok.source_range.start_pos.offset
-        end
+        @scanner.pos = @tok.pos if @tok
       end
 
       # @return [Boolean] Whether or not there's more source text to lex.
@@ -236,11 +222,13 @@ module Sass
 
       def read_token
         return if done?
-        start_pos = source_position
-        value = token
-        return unless value
-        type, val = value
-        Token.new(type, val, range(start_pos), @scanner.pos - @scanner.matched_size)
+        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,
+          current_position - size, @scanner.pos - size)
       end
 
       def whitespace
@@ -250,19 +238,13 @@ module Sass
       end
 
       def token
-        if after_interpolation? && (interp = @interpolation_stack.pop)
-          interp_type, interp_value = interp
-          if interp_type == :special_fun
-            return special_fun_body(interp_value)
-          else
-            raise "[BUG]: Unknown interp_type #{interp_type}" unless interp_type == :string
-            return string(interp_value, true)
-          end
+        if after_interpolation? && (interp_type = @interpolation_stack.pop)
+          return string(interp_type, true)
         end
 
-        variable || string(:double, false) || string(:single, false) || number || id || color ||
-          selector || string(:uri, false) || raw(UNICODERANGE) || special_fun || special_val ||
-          ident_op || ident || op
+        variable || string(:double, false) || string(:single, false) || number || color ||
+          string(:uri, false) || raw(UNICODERANGE) || special_fun || special_val || ident_op ||
+          ident || op
       end
 
       def variable
@@ -281,168 +263,82 @@ module Sass
       end
 
       def string(re, open)
-        line, offset = @line, @offset
         return unless scan(STRING_REGULAR_EXPRESSIONS[re][open])
-        if @scanner[0] =~ /([^\\]|^)\n/
-          filename = @options[:filename]
-          Sass::Util.sass_warn <<MESSAGE
-DEPRECATION WARNING on line #{line}, column #{offset}#{" of #{filename}" if filename}:
-Unescaped multiline strings are deprecated and will be removed in a future version of Sass.
-To include a newline in a string, use "\\a" or "\\a " as in CSS.
-MESSAGE
-        end
-
-        if @scanner[2] == '#{' # '
+        if @scanner[2] == '#{' #'
           @scanner.pos -= 2 # Don't actually consume the #{
-          @offset -= 2
-          @interpolation_stack << [:string, re]
+          @interpolation_stack << re
         end
         str =
           if re == :uri
-            url = "#{'url(' unless open}#{@scanner[1]}#{')' unless @scanner[2] == '#{'}"
-            Script::Value::String.new(url)
+            Script::String.new("#{'url(' unless open}#{@scanner[1]}#{')' unless @scanner[2] == '#{'}")
           else
-            Script::Value::String.new(Sass::Script::Value::String.value(@scanner[1]), :string)
+            Script::String.new(@scanner[1].gsub(/\\(['"]|\#\{)/, '\1'), :string)
           end
         [:string, str]
       end
 
       def number
-        # Handling unary minus is complicated by the fact that whitespace is an
-        # operator in SassScript. We want "1-2" to be parsed as "1 - 2", but we
-        # want "1 -2" to be parsed as "1 (-2)". To accomplish this, we only
-        # parse a unary minus as part of a number literal if there's whitespace
-        # before and not after it. Cases like "(-2)" are handled by the unary
-        # minus logic in the parser instead.
-        if @scanner.peek(1) == '-'
-          return if @scanner.pos == 0
-          unary_minus_allowed =
-            case @scanner.string[@scanner.pos - 1, 1]
-            when /\s/; true
-            when '/'; @scanner.pos != 1 && @scanner.string[@scanner.pos - 2, 1] == '*'
-            else; false
-            end
-
-          return unless unary_minus_allowed
-          return unless scan(REGULAR_EXPRESSIONS[:unary_minus_number])
-          minus = true
-        else
-          return unless scan(REGULAR_EXPRESSIONS[:number])
-          minus = false
-        end
-
-        value = (@scanner[1] ? @scanner[1].to_f : @scanner[2].to_i) * (minus ? -1 : 1)
-        value *= 10**@scanner[3].to_i if @scanner[3]
-        script_number = Script::Value::Number.new(value, Array(@scanner[4]))
-        [:number, script_number]
-      end
-
-      def id
-        # Colors and ids are tough to tell apart, because they overlap but
-        # neither is a superset of the other. "#xyz" is an id but not a color,
-        # "#000" is a color but not an id, "#abc" is both, and "#0" is neither.
-        # We need to handle all these cases correctly.
-        #
-        # To do so, we first try to parse something as an id. If this works and
-        # the id is also a valid color, we return the color. Otherwise, we
-        # return the id. If it didn't parse as an id, we then try to parse it as
-        # a color. If *this* works, we return the color, and if it doesn't we
-        # give up and throw an error.
-        #
-        # IDs in properties are used in the Basic User Interface Module
-        # (http://www.w3.org/TR/css3-ui/).
-        return unless scan(REGULAR_EXPRESSIONS[:id])
-        if @scanner[0] =~ /^\#[0-9a-fA-F]+$/ && (@scanner[0].length == 4 || @scanner[0].length == 7)
-          return [:color, Script::Value::Color.from_hex(@scanner[0])]
-        end
-        [:ident, @scanner[0]]
+        return unless scan(REGULAR_EXPRESSIONS[:number])
+        value = @scanner[2] ? @scanner[2].to_f : @scanner[3].to_i
+        value = -value if @scanner[1]
+        [:number, Script::Number.new(value, Array(@scanner[4]))]
       end
 
       def color
-        return unless @scanner.match?(REGULAR_EXPRESSIONS[:color])
-        return unless @scanner[0].length == 4 || @scanner[0].length == 7
-        script_color = Script::Value::Color.from_hex(scan(REGULAR_EXPRESSIONS[:color]))
-        [:color, script_color]
-      end
-
-      def selector
-        start_pos = source_position
-        return unless scan(REGULAR_EXPRESSIONS[:selector])
-        script_selector = Script::Tree::Selector.new
-        script_selector.source_range = range(start_pos)
-        [:selector, script_selector]
+        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)}
+        [:color, Script::Color.new(value)]
       end
 
       def special_fun
-        prefix = scan(/((-[\w-]+-)?(calc|element)|expression|progid:[a-z\.]*)\(/i)
-        return unless prefix
-        special_fun_body(1, prefix)
-      end
-
-      def special_fun_body(parens, prefix = nil)
-        str = prefix || ''
-        while (scanned = scan(/.*?([()]|\#\{)/m))
-          str << scanned
-          if scanned[-1] == ?(
-            parens += 1
-            next
-          elsif scanned[-1] == ?)
-            parens -= 1
-            next unless parens == 0
-          else
-            raise "[BUG] Unreachable" unless @scanner[1] == '#{' # '
-            str.slice!(-2..-1)
-            @scanner.pos -= 2 # Don't actually consume the #{
-            @offset -= 2
-            @interpolation_stack << [:special_fun, parens]
-          end
-
-          return [:special_fun, Sass::Script::Value::String.new(str)]
-        end
-
-        scan(/.*/)
-        expected!('")"')
+        return unless str1 = scan(/((-[\w-]+-)?(calc|element)|expression|progid:[a-z\.]*)\(/i)
+        str2, _ = Sass::Shared.balance(@scanner, ?(, ?), 1)
+        c = str2.count("\n")
+        old_line = @line
+        old_offset = @offset
+        @line += c
+        @offset = (c == 0 ? @offset + str2.size : str2[/\n(.*)/, 1].size)
+        [:special_fun,
+          Sass::Util.merge_adjacent_strings(
+            [str1] + Sass::Engine.parse_interp(str2, old_line, old_offset, @options)),
+          str1.size + str2.size]
       end
 
       def special_val
         return unless scan(/!important/i)
-        [:string, Script::Value::String.new("!important")]
+        [:string, Script::String.new("!important")]
       end
 
       def ident_op
-        op = scan(REGULAR_EXPRESSIONS[:ident_op])
-        return unless op
+        return unless op = scan(REGULAR_EXPRESSIONS[:ident_op])
         [OPERATORS[op]]
       end
 
       def op
-        op = scan(REGULAR_EXPRESSIONS[:op])
-        return unless op
+        return unless op = scan(REGULAR_EXPRESSIONS[:op])
         @interpolation_stack << nil if op == :begin_interpolation
         [OPERATORS[op]]
       end
 
       def raw(rx)
-        val = scan(rx)
-        return unless val
+        return unless val = scan(rx)
         [:raw, val]
       end
 
       def scan(re)
-        str = @scanner.scan(re)
-        return unless str
+        return unless str = @scanner.scan(re)
         c = str.count("\n")
         @line += c
-        @offset = (c == 0 ? @offset + str.size : str.size - str.rindex("\n"))
+        @offset = (c == 0 ? @offset + str.size : str[/\n(.*)/, 1].size)
         str
       end
 
-      def range(start_pos, end_pos = source_position)
-        Sass::Source::Range.new(start_pos, end_pos, @options[:filename], @options[:importer])
-      end
-
-      def source_position
-        Sass::Source::Position.new(@line, @offset)
+      def current_position
+        @offset + 1
       end
     end
   end

data/lib/sass/script/list.rb

@@ -0,0 +1,85 @@
+module Sass::Script
+  # A SassScript object representing a CSS list.
+  # This includes both comma-separated lists and space-separated lists.
+  class List < Literal
+    # The Ruby array containing the contents of the list.
+    #
+    # @return [Array<Literal>]
+    attr_reader :value
+    alias_method :children, :value
+    alias_method :to_a, :value
+
+    # The operator separating the values of the list.
+    # Either `:comma` or `:space`.
+    #
+    # @return [Symbol]
+    attr_reader :separator
+
+    # Creates a new list.
+    #
+    # @param value [Array<Literal>] See \{#value}
+    # @param separator [String] See \{#separator}
+    def initialize(value, separator)
+      super(value)
+      @separator = separator
+    end
+
+    # @see Node#deep_copy
+    def deep_copy
+      node = dup
+      node.instance_variable_set('@value', value.map {|c| c.deep_copy})
+      node
+    end
+
+    # @see Node#eq
+    def eq(other)
+      Sass::Script::Bool.new(
+        other.is_a?(List) && self.value == other.value &&
+        self.separator == other.separator)
+    end
+
+    # @see Node#to_s
+    def to_s(opts = {})
+      raise Sass::SyntaxError.new("() isn't a valid CSS value.") if value.empty?
+      return value.reject {|e| e.is_a?(Null) || e.is_a?(List) && e.value.empty?}.map {|e| e.to_s(opts)}.join(sep_str)
+    end
+
+    # @see Node#to_sass
+    def to_sass(opts = {})
+      return "()" if value.empty?
+      precedence = Sass::Script::Parser.precedence_of(separator)
+      value.reject {|e| e.is_a?(Null)}.map do |v|
+        if v.is_a?(List) && Sass::Script::Parser.precedence_of(v.separator) <= precedence ||
+            separator == :space && v.is_a?(UnaryOperation) && (v.operator == :minus || v.operator == :plus)
+          "(#{v.to_sass(opts)})"
+        else
+          v.to_sass(opts)
+        end
+      end.join(sep_str(nil))
+    end
+
+    # @see Node#inspect
+    def inspect
+      "(#{to_sass})"
+    end
+
+    protected
+
+    # @see Node#_perform
+    def _perform(environment)
+      list = Sass::Script::List.new(
+        value.map {|e| e.perform(environment)},
+        separator)
+      list.options = self.options
+      list
+    end
+
+    private
+
+    def sep_str(opts = self.options)
+      return ' ' if separator == :space
+      return ',' if opts && opts[:style] == :compressed
+      return ', '
+    end
+  end
+end