sass 3.4.19 → 3.4.20

data/lib/sass/script/tree/interpolation.rb

@@ -27,6 +27,17 @@ module Sass::Script::Tree
     #   generate a warning.
     attr_reader :warn_for_color
 
+    # The type of interpolation deprecation for this node.
+    #
+    # This can be `:none`, indicating that the node doesn't use deprecated
+    # interpolation; `:immediate`, indicating that a deprecation warning should
+    # be emitted as soon as possible; or `:potential`, indicating that a
+    # deprecation warning should be emitted if the resulting string is used in a
+    # way that would distinguish it from a list.
+    #
+    # @return [Symbol]
+    attr_reader :deprecation
+
     # Interpolation in a property is of the form `before #{mid} after`.
     #
     # @param before [Node] See {Interpolation#before}
@@ -38,15 +49,16 @@ module Sass::Script::Tree
     # @param warn_for_color [Boolean] See {Interpolation#warn_for_color}
     # @comment
     #   rubocop:disable ParameterLists
-    def initialize(before, mid, after, wb, wa, originally_text = false, warn_for_color = false)
+    def initialize(before, mid, after, wb, wa, opts = {})
       # rubocop:enable ParameterLists
       @before = before
       @mid = mid
       @after = after
       @whitespace_before = wb
       @whitespace_after = wa
-      @originally_text = originally_text
-      @warn_for_color = warn_for_color
+      @originally_text = opts[:originally_text] || false
+      @warn_for_color = opts[:warn_for_color] || false
+      @deprecation = opts[:deprecation] || :none
     end
 
     # @return [String] A human-readable s-expression representation of the interpolation
@@ -56,6 +68,8 @@ module Sass::Script::Tree
 
     # @see Node#to_sass
     def to_sass(opts = {})
+      return to_quoted_equivalent.to_sass if deprecation == :immediate
+
       res = ""
       res << @before.to_sass(opts) if @before
       res << ' ' if @before && @whitespace_before
@@ -67,6 +81,19 @@ module Sass::Script::Tree
       res
     end
 
+    # Returns an `unquote()` expression that will evaluate to the same value as
+    # this interpolation.
+    #
+    # @return [Sass::Script::Tree::Node]
+    def to_quoted_equivalent
+      Funcall.new(
+        "unquote",
+        [to_string_interpolation(self)],
+        Sass::Util::NormalizedMap.new,
+        nil,
+        nil)
+    end
+
     # Returns the three components of the interpolation, `before`, `mid`, and `after`.
     #
     # @return [Array<Node>]
@@ -87,6 +114,49 @@ module Sass::Script::Tree
 
     protected
 
+    # Converts a script node into a corresponding string interpolation
+    # expression.
+    #
+    # @param node_or_interp [Sass::Script::Tree::Node]
+    # @return [Sass::Script::Tree::StringInterpolation]
+    def to_string_interpolation(node_or_interp)
+      unless node_or_interp.is_a?(Interpolation)
+        node = node_or_interp
+        return string_literal(node.value.to_s) if node.is_a?(Literal)
+        if node.is_a?(StringInterpolation)
+          return concat(string_literal(node.quote), concat(node, string_literal(node.quote)))
+        end
+        return StringInterpolation.new(string_literal(""), node, string_literal(""))
+      end
+
+      interp = node_or_interp
+      after_string_or_interp =
+        if interp.after
+          to_string_interpolation(interp.after)
+        else
+          string_literal("")
+        end
+      if interp.after && interp.whitespace_after
+        after_string_or_interp = concat(string_literal(' '), after_string_or_interp)
+      end
+
+      mid_string_or_interp = to_string_interpolation(interp.mid)
+
+      before_string_or_interp =
+        if interp.before
+          to_string_interpolation(interp.before)
+        else
+          string_literal("")
+        end
+      if interp.before && interp.whitespace_before
+        before_string_or_interp = concat(before_string_or_interp, string_literal(' '))
+      end
+
+      concat(before_string_or_interp, concat(mid_string_or_interp, after_string_or_interp))
+    end
+
+    private
+
     # Evaluates the interpolation.
     #
     # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
@@ -112,7 +182,42 @@ MESSAGE
       res << val.to_s(:quote => :none)
       res << " " if @after && @whitespace_after
       res << @after.perform(environment).to_s if @after
-      opts(Sass::Script::Value::String.new(res))
+      str = Sass::Script::Value::String.new(
+        res, :identifier,
+        (to_quoted_equivalent.to_sass if deprecation == :potential))
+      str.source_range = source_range
+      opts(str)
+    end
+
+    # Concatenates two string literals or string interpolation expressions.
+    #
+    # @param string_or_interp1 [Sass::Script::Tree::Literal|Sass::Script::Tree::StringInterpolation]
+    # @param string_or_interp2 [Sass::Script::Tree::Literal|Sass::Script::Tree::StringInterpolation]
+    # @return [Sass::Script::Tree::StringInterpolation]
+    def concat(string_or_interp1, string_or_interp2)
+      if string_or_interp1.is_a?(Literal) && string_or_interp2.is_a?(Literal)
+        return string_literal(string_or_interp1.value.value + string_or_interp2.value.value)
+      end
+
+      if string_or_interp1.is_a?(Literal)
+        string = string_or_interp1
+        interp = string_or_interp2
+        before = string_literal(string.value.value + interp.before.value.value)
+        return StringInterpolation.new(before, interp.mid, interp.after)
+      end
+
+      StringInterpolation.new(
+        string_or_interp1.before,
+        string_or_interp1.mid,
+        concat(string_or_interp1.after, string_or_interp2))
+    end
+
+    # Returns a string literal with the given contents.
+    #
+    # @param string [String]
+    # @return string [Sass::Script::Tree::Literal]
+    def string_literal(string)
+      Literal.new(Sass::Script::Value::String.new(string, :string))
     end
   end
 end

data/lib/sass/script/tree/string_interpolation.rb

@@ -24,6 +24,12 @@ module Sass::Script::Tree
       @before.value.type
     end
 
+    # Returns the quote character that should be used to wrap a Sass
+    # representation of this interpolation.
+    def quote
+      quote_for(self) || '"'
+    end
+
     # Interpolation in a string is of the form `"before #{mid} after"`,
     # where `before` and `after` may include more interpolation.
     #

data/lib/sass/script/value/number.rb

@@ -289,6 +289,9 @@ module Sass::Script::Value
       # and confusing.
       str = ("%0.#{self.class.precision}f" % value).gsub(/0*$/, '') if str.include?('e')
 
+      if @options && options[:style] == :compressed
+        str.sub!(/^(-)?0\./, '\1.')
+      end
       unitless? ? str : "#{str}#{unit_str}"
     end
     alias_method :to_sass, :inspect
@@ -478,6 +481,7 @@ module Sass::Script::Value
         'cm' => Rational(1, 2.54),
         'pc' => Rational(1, 6),
         'mm' => Rational(1, 25.4),
+        'q' => Rational(1, 101.6),
         'pt' => Rational(1, 72),
         'px' => Rational(1, 96)
       },

data/lib/sass/script/value/string.rb

@@ -76,9 +76,13 @@ module Sass::Script::Value
     #
     # @param value [String] See \{#value}
     # @param type [Symbol] See \{#type}
-    def initialize(value, type = :identifier)
+    # @param deprecated_interp_equivalent [String?]
+    #   If this was created via a potentially-deprecated string interpolation,
+    #   this is the replacement expression that should be suggested to the user.
+    def initialize(value, type = :identifier, deprecated_interp_equivalent = nil)
       super(value)
       @type = type
+      @deprecated_interp_equivalent = deprecated_interp_equivalent
     end
 
     # @see Value#plus
@@ -102,6 +106,38 @@ module Sass::Script::Value
       to_s(opts.merge(:sass => true))
     end
 
+    def separator
+      check_deprecated_interp
+      super
+    end
+
+    def to_a
+      check_deprecated_interp
+      super
+    end
+
+    # Prints a warning if this string was created using potentially-deprecated
+    # interpolation.
+    def check_deprecated_interp
+      return unless @deprecated_interp_equivalent
+
+      # rubocop:disable GlobalVars
+      $_sass_deprecated_interp_warnings ||= Set.new
+      key = [source_range.start_pos.line, source_range.file, @deprecated_interp_equivalent]
+      return if $_sass_deprecated_interp_warnings.include?(key)
+      $_sass_deprecated_interp_warnings << key
+      # rubocop:enable GlobalVars
+
+      location = "on line #{source_range.start_pos.line}"
+      location << " of #{source_range.file}" if source_range.file
+      Sass::Util.sass_warn <<WARNING
+DEPRECATION WARNING #{location}: \#{} interpolation near operators will be simplified
+in a future version of Sass. To preserve the current behavior, use quotes:
+
+  #{@deprecated_interp_equivalent}
+WARNING
+    end
+
     def inspect
       String.quote(value)
     end

data/lib/sass/scss/parser.rb

@@ -55,6 +55,15 @@ module Sass
         interp_ident
       end
 
+      # Parses a supports clause for an @import directive
+      def parse_supports_clause
+        init_scanner!
+        ss
+        clause = supports_clause
+        ss
+        clause
+      end
+
       # Parses a media query list.
       #
       # @return [Sass::Media::QueryList] The parsed query list
@@ -150,20 +159,16 @@ module Sass
         silent = text =~ %r{\A//}
         loud = !silent && text =~ %r{\A/[/*]!}
         line = @line - text.count("\n")
+        comment_start = @scanner.pos - text.length
+        index_before_line = @scanner.string.rindex("\n", comment_start) || -1
+        offset = comment_start - index_before_line
 
         if silent
           value = [text.sub(%r{\A\s*//}, '/*').gsub(%r{^\s*//}, ' *') + ' */']
         else
-          value = Sass::Engine.parse_interp(
-            text, line, @scanner.pos - text.size, :filename => @filename)
-          newline_before_comment = @scanner.string.rindex("\n", @scanner.pos - text.length)
-          last_line_before_comment =
-            if newline_before_comment
-              @scanner.string[newline_before_comment + 1...@scanner.pos - text.length]
-            else
-              @scanner.string[0...@scanner.pos - text.length]
-            end
-          value.unshift(last_line_before_comment.gsub(/[^\s]/, ' '))
+          value = Sass::Engine.parse_interp(text, line, offset, :filename => @filename)
+          line_before_comment = @scanner.string[index_before_line + 1...comment_start]
+          value.unshift(line_before_comment.gsub(/[^\s]/, ' '))
         end
 
         type = if silent
@@ -173,8 +178,8 @@ module Sass
                else
                  :normal
                end
-        comment = Sass::Tree::CommentNode.new(value, type)
-        comment.line = line
+        start_pos = Sass::Source::Position.new(line, offset)
+        comment = node(Sass::Tree::CommentNode.new(value, type), start_pos)
         node << comment
       end
 
@@ -379,16 +384,20 @@ module Sass
         if uri
           str = sass_script(:parse_string)
           ss
+          supports = supports_clause
+          ss
           media = media_query_list
           ss
-          return node(Tree::CssImportNode.new(str, media.to_a), start_pos)
+          return node(Tree::CssImportNode.new(str, media.to_a, supports), start_pos)
         end
         ss
 
+        supports = supports_clause
+        ss
         media = media_query_list
-        if str =~ %r{^(https?:)?//} || media || use_css_import?
+        if str =~ %r{^(https?:)?//} || media || supports || use_css_import?
           return node(Sass::Tree::CssImportNode.new(
-              Sass::Script::Value::String.quote(str), media.to_a), start_pos)
+              Sass::Script::Value::String.quote(str), media.to_a, supports), start_pos)
         end
 
         node(Sass::Tree::ImportNode.new(str.strip), start_pos)
@@ -548,6 +557,15 @@ module Sass
         node(node, start_pos)
       end
 
+      def supports_clause
+        return unless tok(/supports\(/i)
+        ss
+        supports = supports_condition
+        ss
+        tok!(/\)/)
+        supports
+      end
+
       def supports_condition
         supports_negation || supports_operator || supports_interpolation
       end

data/lib/sass/selector/simple_sequence.rb

@@ -166,7 +166,7 @@ module Sass
           extended.members.reject! {|seq| seq.has_placeholder?}
 
           # For `:not()`, we usually want to get rid of any complex
-          # selectors becuase that will cause the selector to fail to
+          # selectors because that will cause the selector to fail to
           # parse on all browsers at time of writing. We can keep them
           # if either the original selector had a complex selector, or
           # the result of extending has only complex selectors,

data/lib/sass/tree/css_import_node.rb

@@ -15,6 +15,11 @@ module Sass::Tree
     # @return [String]
     attr_accessor :resolved_uri
 
+    # The supports condition for this import.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :supports_condition
+
     # The media query for this rule, interspersed with
     # {Sass::Script::Tree::Node}s representing `#{}`-interpolation. Any adjacent
     # strings will be merged together.
@@ -30,9 +35,11 @@ module Sass::Tree
 
     # @param uri [String, Sass::Script::Tree::Node] See \{#uri}
     # @param query [Array<String, Sass::Script::Tree::Node>] See \{#query}
-    def initialize(uri, query = [])
+    # @param supports_condition [Sass::Supports::Condition] See \{#supports_condition}
+    def initialize(uri, query = [], supports_condition = nil)
       @uri = uri
       @query = query
+      @supports_condition = supports_condition
       super('')
     end
 
@@ -52,6 +59,7 @@ module Sass::Tree
       @resolved_value ||=
         begin
           str = "@import #{resolved_uri}"
+          str << " supports(#{supports_condition.to_css})" if supports_condition
           str << " #{resolved_query.to_css}" if resolved_query
           str
         end

data/lib/sass/tree/visitors/convert.rb

@@ -163,6 +163,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     else
       str = "#{tab_str}@import #{node.uri}"
     end
+    str << " supports(#{node.supports_condition.to_src(@options)})" if node.supports_condition
     str << " #{interp_to_src(node.query)}" unless node.query.empty?
     "#{str}#{semi}\n"
   end

data/lib/sass/tree/visitors/perform.rb

@@ -526,6 +526,9 @@ WARNING
         node.filename, node.options[:importer], node.line)
       node.resolved_query ||= parser.parse_media_query_list
     end
+    if node.supports_condition
+      node.supports_condition.perform(@environment)
+    end
     yield
   end
 

data/lib/sass/tree/visitors/to_css.rb

@@ -159,8 +159,9 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
   def visit_comment(node)
     return if node.invisible?
     spaces = ('  ' * [@tabs - node.resolved_value[/^ */].size, 0].max)
+    output(spaces)
 
-    content = node.resolved_value.gsub(/^/, spaces)
+    content = node.resolved_value.split("\n").join("\n" + spaces)
     if node.type == :silent
       content.gsub!(%r{^(\s*)//(.*)$}) {|md| "#{$1}/*#{$2} */"}
     end
@@ -297,7 +298,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
         rule_part = seq.to_s
         if node.style == :compressed
           rule_part.gsub!(/([^,])\s*\n\s*/m, '\1 ')
-          rule_part.gsub!(/\s*([,+>])\s*/m, '\1')
+          rule_part.gsub!(/\s*([-,+>])\s*/m, '\1')
           rule_part.strip!
         end
         rule_part

data/lib/sass/util.rb

@@ -144,9 +144,10 @@ module Sass
     # @param value [Numeric]
     # @return [Numeric]
     def round(value)
-      # If the number is within epsilon of X.5, round up.
-      return value.ceil if (value % 1) - 0.5 > -0.00001
-      value.round
+      # If the number is within epsilon of X.5, round up (or down for negative
+      # numbers).
+      return value.round if (value % 1) - 0.5 <= -1 * Script::Value::Number.epsilon
+      value > 0 ? value.ceil : value.floor
     end
 
     # Concatenates all strings that are adjacent in an array,

data/test/sass/conversion_test.rb

@@ -2112,6 +2112,14 @@ foo {
 SCSS
   end
 
+  def test_import_with_supports_clause
+    assert_renders(<<'SASS', <<'SCSS')
+@import url("fallback-layout.css") supports(not (display: #{$display-type}))
+SASS
+@import url("fallback-layout.css") supports(not (display: #{$display-type}));
+SCSS
+  end
+
   private
 
   def assert_sass_to_sass(sass, options = {})