sass 3.4.24 → 3.7.4

data/lib/sass/tree/prop_node.rb

@@ -20,7 +20,11 @@ module Sass::Tree
 
     # The value of the property.
     #
-    # @return [Sass::Script::Tree::Node]
+    # For most properties, this will just contain a single Node. However, for
+    # CSS variables, it will contain multiple strings and nodes representing
+    # interpolation. Any adjacent strings will be merged together.
+    #
+    # @return [Array<String, Sass::Script::Tree::Node>]
     attr_accessor :value
 
     # The value of the property
@@ -52,14 +56,22 @@ module Sass::Tree
     # @return [Sass::Source::Range]
     attr_accessor :value_source_range
 
+    # Whether this represents a CSS custom property.
+    #
+    # @return [Boolean]
+    def custom_property?
+      name.first.is_a?(String) && name.first.start_with?("--")
+    end
+
     # @param name [Array<String, Sass::Script::Tree::Node>] See \{#name}
-    # @param value [Sass::Script::Tree::Node] See \{#value}
+    # @param value [Array<String, Sass::Script::Tree::Node>] See \{#value}
     # @param prop_syntax [Symbol] `:new` if this property uses `a: b`-style syntax,
     #   `:old` if it uses `:a b`-style syntax
     def initialize(name, value, prop_syntax)
       @name = Sass::Util.strip_string_array(
         Sass::Util.merge_adjacent_strings(name))
-      @value = value
+      @value = Sass::Util.merge_adjacent_strings(value)
+      @value = Sass::Util.strip_string_array(@value) unless custom_property?
       @tabs = 0
       @prop_syntax = prop_syntax
       super()
@@ -81,9 +93,10 @@ module Sass::Tree
     # @return [String] The message
     def pseudo_class_selector_message
       if @prop_syntax == :new ||
-          !value.is_a?(Sass::Script::Tree::Literal) ||
-          !value.value.is_a?(Sass::Script::Value::String) ||
-          !value.value.value.empty?
+          custom_property? ||
+          !value.first.is_a?(Sass::Script::Tree::Literal) ||
+          !value.first.value.is_a?(Sass::Script::Value::String) ||
+          !value.first.value.value.empty?
         return ""
       end
 
@@ -98,73 +111,52 @@ module Sass::Tree
     # @param fmt [Symbol] `:scss` or `:sass`.
     def declaration(opts = {:old => @prop_syntax == :old}, fmt = :sass)
       name = self.name.map {|n| n.is_a?(String) ? n : n.to_sass(opts)}.join
+      value = self.value.map {|n| n.is_a?(String) ? n : n.to_sass(opts)}.join
+      value = "(#{value})" if value_needs_parens?
+
       if name[0] == ?:
-        raise Sass::SyntaxError.new("The \"#{name}: #{self.class.val_to_sass(value, opts)}\"" +
+        raise Sass::SyntaxError.new("The \"#{name}: #{value}\"" +
                                     " hack is not allowed in the Sass indented syntax")
       end
 
+      # The indented syntax doesn't support newlines in custom property values,
+      # but we can losslessly convert them to spaces instead.
+      value = value.tr("\n", " ") if fmt == :sass
+
       old = opts[:old] && fmt == :sass
-      initial = old ? ':' : ''
-      mid = old ? '' : ':'
-      "#{initial}#{name}#{mid} #{self.class.val_to_sass(value, opts)}".rstrip
+      "#{old ? ':' : ''}#{name}#{old ? '' : ':'}#{custom_property? ? '' : ' '}#{value}".rstrip
     end
 
     # A property node is invisible if its value is empty.
     #
     # @return [Boolean]
     def invisible?
-      resolved_value.empty?
+      !custom_property? && resolved_value.empty?
     end
 
     private
 
+    # Returns whether \{#value} neesd parentheses in order to be parsed
+    # properly as division.
+    def value_needs_parens?
+      return false if custom_property?
+
+      root = value.first
+      root.is_a?(Sass::Script::Tree::Operation) &&
+        root.operator == :div &&
+        root.operand1.is_a?(Sass::Script::Tree::Literal) &&
+        root.operand1.value.is_a?(Sass::Script::Value::Number) &&
+        root.operand1.value.original.nil? &&
+        root.operand2.is_a?(Sass::Script::Tree::Literal) &&
+        root.operand2.value.is_a?(Sass::Script::Value::Number) &&
+        root.operand2.value.original.nil?
+    end
+
     def check!
       return unless @options[:property_syntax] && @options[:property_syntax] != @prop_syntax
       raise Sass::SyntaxError.new(
         "Illegal property syntax: can't use #{@prop_syntax} syntax when " +
         ":property_syntax => #{@options[:property_syntax].inspect} is set.")
     end
-
-    class << self
-      # @private
-      def val_to_sass(value, opts)
-        val_to_sass_comma(value, opts).to_sass(opts)
-      end
-
-      private
-
-      def val_to_sass_comma(node, opts)
-        return node unless node.is_a?(Sass::Script::Tree::Operation)
-        return val_to_sass_concat(node, opts) unless node.operator == :comma
-
-        Sass::Script::Tree::Operation.new(
-          val_to_sass_concat(node.operand1, opts),
-          val_to_sass_comma(node.operand2, opts),
-          node.operator)
-      end
-
-      def val_to_sass_concat(node, opts)
-        return node unless node.is_a?(Sass::Script::Tree::Operation)
-        return val_to_sass_div(node, opts) unless node.operator == :space
-
-        Sass::Script::Tree::Operation.new(
-          val_to_sass_div(node.operand1, opts),
-          val_to_sass_concat(node.operand2, opts),
-          node.operator)
-      end
-
-      def val_to_sass_div(node, opts)
-        unless node.is_a?(Sass::Script::Tree::Operation) && node.operator == :div &&
-            node.operand1.is_a?(Sass::Script::Tree::Literal) &&
-            node.operand1.value.is_a?(Sass::Script::Value::Number) &&
-            node.operand2.is_a?(Sass::Script::Tree::Literal) &&
-            node.operand2.value.is_a?(Sass::Script::Value::Number) &&
-            (!node.operand1.value.original || !node.operand2.value.original)
-          return node
-        end
-
-        Sass::Script::Value::String.new("(#{node.to_sass(opts)})")
-      end
-    end
   end
 end

data/lib/sass/tree/rule_node.rb

@@ -120,13 +120,14 @@ module Sass::Tree
     #
     # @return [{#to_s => #to_s}]
     def debug_info
-      {:filename => filename && ("file://" + Sass::Util.escape_uri(File.expand_path(filename))),
+      {:filename => filename &&
+         ("file://" + URI::DEFAULT_PARSER.escape(File.expand_path(filename))),
        :line => line}
     end
 
     # A rule node is invisible if it has only placeholder selectors.
     def invisible?
-      resolved_rules.members.all? {|seq| seq.has_placeholder?}
+      resolved_rules.members.all? {|seq| seq.invisible?}
     end
 
     private
@@ -137,10 +138,16 @@ module Sass::Tree
 
       # We don't use real filename/line info because we don't have it yet.
       # When we get it, we'll set it on the parsed rules if possible.
-      parser = Sass::SCSS::StaticParser.new(@rule.join.strip, nil, nil, 1)
-      # rubocop:disable RescueModifier
-      @parsed_rules = parser.parse_selector rescue nil
-      # rubocop:enable RescueModifier
+      parser = nil
+      warnings = Sass.logger.capture do
+        parser = Sass::SCSS::StaticParser.new(
+          Sass::Util.strip_except_escapes(@rule.join), nil, nil, 1)
+        @parsed_rules = parser.parse_selector rescue nil
+      end
+
+      # If parsing produces a warning, throw away the result so we can parse
+      # later with the real filename info.
+      @parsed_rules = nil unless warnings.empty?
     end
   end
 end

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

@@ -31,7 +31,7 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
     if parent.is_a?(Sass::Tree::AtRootNode) && parent.resolved_value
       old_parents = @parents
       @parents = @parents.reject {|p| parent.exclude_node?(p)}
-      @parent = Sass::Util.enum_with_index(@parents.reverse).
+      @parent = @parents.reverse.each_with_index.
         find {|p, i| !transparent_parent?(p, @parents[-i - 2])}.first
 
       begin

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

@@ -203,8 +203,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
     unless node.args.empty? && node.keywords.empty? && node.splat.nil?
       args = node.args.map(&arg_to_sass)
-      keywords = Sass::Util.hash_to_a(node.keywords.as_stored).
-        map {|k, v| "$#{dasherize(k)}: #{arg_to_sass[v]}"}
+      keywords = node.keywords.as_stored.to_a.map {|k, v| "$#{dasherize(k)}: #{arg_to_sass[v]}"}
 
       if node.splat
         splat = "#{arg_to_sass[node.splat]}..."
@@ -281,7 +280,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   # Visit rule-level nodes and return their conversion with appropriate
   # whitespace added.
   def visit_rule_level(nodes)
-    Sass::Util.enum_cons(nodes + [nil], 2).map do |child, nxt|
+    (nodes + [nil]).each_cons(2).map do |child, nxt|
       visit(child) +
         if nxt &&
             (child.is_a?(Sass::Tree::CommentNode) && child.line + child.lines + 1 == nxt.line) ||

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

@@ -56,8 +56,7 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     @parents.pop
   end
 
-  # In Ruby 1.8, ensures that there's only one `@charset` directive
-  # and that it's at the top of the document.
+  # Converts the entire document to CSS.
   #
   # @return [(Tree::Node, Sass::Util::SubsetMap)] The resulting tree of static nodes
   #   *and* the extensions defined for this tree
@@ -65,14 +64,6 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     yield
 
     if parent.nil?
-      # In Ruby 1.9 we can make all @charset nodes invisible
-      # and infer the final @charset from the encoding of the final string.
-      if Sass::Util.ruby1_8?
-        charset = node.children.find {|c| c.is_a?(Sass::Tree::CharsetNode)}
-        node.children.reject! {|c| c.is_a?(Sass::Tree::CharsetNode)}
-        node.children.unshift charset if charset
-      end
-
       imports_to_move = []
       import_limit = nil
       i = -1
@@ -115,11 +106,9 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   # @attr node [Sass::Tree::ExtendNode] The node that produced this extend.
   # @attr directives [Array<Sass::Tree::DirectiveNode>]
   #   The directives containing the `@extend`.
-  # @attr result [Symbol]
-  #   The result of this extend. One of `:not_found` (the target doesn't exist
-  #   in the document), `:failed_to_unify` (the target exists but cannot be
-  #   unified with the extender), or `:succeeded`.
-  Extend = Struct.new(:extender, :target, :node, :directives, :result)
+  # @attr success [Boolean]
+  #   Whether this extend successfully matched a selector.
+  Extend = Struct.new(:extender, :target, :node, :directives, :success)
 
   # Registers an extension in the `@extends` subset map.
   def visit_extend(node)

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

@@ -55,13 +55,13 @@ class Sass::Tree::Visitors::DeepCopy < Sass::Tree::Visitors::Base
 
   def visit_mixin(node)
     node.args = node.args.map {|a| a.deep_copy}
-    node.keywords = Hash[node.keywords.map {|k, v| [k, v.deep_copy]}]
+    node.keywords = Sass::Util::NormalizedMap.new(Hash[node.keywords.map {|k, v| [k, v.deep_copy]}])
     yield
   end
 
   def visit_prop(node)
     node.name = node.name.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c}
-    node.value = node.value.deep_copy
+    node.value = node.value.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c}
     yield
   end
 

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

@@ -49,19 +49,13 @@ class Sass::Tree::Visitors::Extend < Sass::Tree::Visitors::Base
 
     def check_extends_fired!(extends)
       extends.each_value do |ex|
-        next if ex.result == :succeeded || ex.node.optional?
+        next if ex.success || ex.node.optional?
         message = "\"#{ex.extender}\" failed to @extend \"#{ex.target.join}\"."
-        reason =
-          if ex.result == :not_found
-            "The selector \"#{ex.target.join}\" was not found."
-          else
-            "No selectors matching \"#{ex.target.join}\" could be unified with \"#{ex.extender}\"."
-          end
 
         # TODO(nweiz): this should use the Sass stack trace of the extend node.
         raise Sass::SyntaxError.new(<<MESSAGE, :filename => ex.node.filename, :line => ex.node.line)
 #{message}
-#{reason}
+The selector "#{ex.target.join}" was not found.
 Use "@extend #{ex.target.join} !optional" if the extend should be able to fail.
 MESSAGE
       end

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

@@ -1,5 +1,7 @@
 # A visitor for converting a dynamic Sass tree into a static Sass tree.
 class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
+  @@function_name_deprecation = Sass::Deprecation.new
+
   class << self
     # @param root [Tree::Node] The root node of the tree to visit.
     # @param environment [Sass::Environment] The lexical environment.
@@ -9,8 +11,6 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     end
 
     # @api private
-    # @comment
-    #   rubocop:disable MethodLength
     def perform_arguments(callable, args, splat, environment)
       desc = "#{callable.type.capitalize} #{callable.name}"
       downcase_desc = "#{callable.type} #{callable.name}"
@@ -143,8 +143,6 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
       end
     end
   end
-  # @comment
-  #   rubocop:enable MethodLength
 
   protected
 
@@ -280,8 +278,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
     if node.normalized_name == 'calc' || node.normalized_name == 'element' ||
         node.name == 'expression' || node.name == 'url'
-      Sass::Util.sass_warn <<WARNING
-DEPRECATION WARNING on line #{node.line}#{" of #{node.filename}" if node.filename}:
+      @@function_name_deprecation.warn(node.filename, node.line, <<WARNING)
 Naming a function "#{node.name}" is disallowed and will be an error in future versions of Sass.
 This name conflicts with an existing CSS function with special parse rules.
 WARNING
@@ -289,7 +286,7 @@ WARNING
 
     @environment.set_local_function(node.name,
       Sass::Callable.new(node.name, node.args, node.splat, env,
-                         node.children, false, "function"))
+                         node.children, false, "function", :stylesheet))
     []
   end
 
@@ -340,7 +337,7 @@ WARNING
     env = Sass::Environment.new(@environment, node.options)
     @environment.set_local_mixin(node.name,
       Sass::Callable.new(node.name, node.args, node.splat, env,
-                         node.children, node.has_content, "mixin"))
+                         node.children, node.has_content, "mixin", :stylesheet))
     []
   end
 
@@ -350,7 +347,7 @@ WARNING
       mixin = @environment.mixin(node.name)
       raise Sass::SyntaxError.new("Undefined mixin '#{node.name}'.") unless mixin
 
-      if node.children.any? && !mixin.has_content
+      if node.has_children && !mixin.has_content
         raise Sass::SyntaxError.new(%(Mixin "#{node.name}" does not accept a content block.))
       end
 
@@ -394,9 +391,19 @@ WARNING
   # Runs any SassScript that may be embedded in a property.
   def visit_prop(node)
     node.resolved_name = run_interp(node.name)
-    val = node.value.perform(@environment)
-    node.resolved_value = val.to_s
-    node.value_source_range = val.source_range if val.source_range
+
+    # If the node's value is just a variable or similar, we may get a useful
+    # source range from evaluating it.
+    if node.value.length == 1 && node.value.first.is_a?(Sass::Script::Tree::Node)
+      result = node.value.first.perform(@environment)
+      node.resolved_value = result.to_s
+      node.value_source_range = result.source_range if result.source_range
+    elsif node.custom_property?
+      node.resolved_value = run_interp_no_strip(node.value)
+    else
+      node.resolved_value = run_interp(node.value)
+    end
+
     yield
   end
 
@@ -482,9 +489,11 @@ WARNING
   def visit_warn(node)
     res = node.expr.perform(@environment)
     res = res.value if res.is_a?(Sass::Script::Value::String)
-    msg = "WARNING: #{res}\n         "
-    msg << @environment.stack.to_s.gsub("\n", "\n         ") << "\n"
-    Sass::Util.sass_warn msg
+    @environment.stack.with_directive(node.filename, node.line, "@warn") do
+      msg = "WARNING: #{res}\n         "
+      msg << @environment.stack.to_s.gsub("\n", "\n         ") << "\n"
+      Sass::Util.sass_warn msg
+    end
     []
   end
 
@@ -544,7 +553,7 @@ WARNING
   end
 
   def run_interp(text)
-    run_interp_no_strip(text).strip
+    Sass::Util.strip_except_escapes(run_interp_no_strip(text))
   end
 
   def handle_import_loop!(node)
@@ -555,7 +564,7 @@ WARNING
     end
 
     files << node.filename << node.imported_file.options[:filename]
-    msg << "\n" << Sass::Util.enum_cons(files, 2).map do |m1, m2|
+    msg << "\n" << files.each_cons(2).map do |m1, m2|
       "    #{m1} imports #{m2}"
     end.join("\n")
     raise Sass::SyntaxError.new(msg)

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

@@ -88,7 +88,7 @@ class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
 
   def visit_prop(node)
     node.name.each {|c| c.options = @options if c.is_a?(Sass::Script::Tree::Node)}
-    node.value.options = @options
+    node.value.each {|c| c.options = @options if c.is_a?(Sass::Script::Tree::Node)}
     yield
   end
 

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

@@ -135,7 +135,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
     output "\n"
 
-    unless Sass::Util.ruby1_8? || @result.ascii_only?
+    unless @result.ascii_only?
       if node.style == :compressed
         # A byte order mark is sufficient to tell browsers that this
         # file is UTF-8 encoded, and will override any other detection
@@ -171,8 +171,6 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     for_node(node) {output(content)}
   end
 
-  # @comment
-  #   rubocop:disable MethodLength
   def visit_directive(node)
     was_in_directive = @in_directive
     tab_str = '  ' * @tabs
@@ -244,8 +242,6 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
   ensure
     @in_directive = was_in_directive
   end
-  # @comment
-  #   rubocop:enable MethodLength
 
   def visit_media(node)
     with_tabs(@tabs + node.tabs) {visit_directive(node)}
@@ -261,22 +257,22 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
   end
 
   def visit_prop(node)
-    return if node.resolved_value.empty?
+    return if node.resolved_value.empty? && !node.custom_property?
     tab_str = '  ' * (@tabs + node.tabs)
     output(tab_str)
     for_node(node, :name) {output(node.resolved_name)}
-    if node.style == :compressed
-      output(":")
-      for_node(node, :value) {output(node.resolved_value)}
-    else
-      output(": ")
-      for_node(node, :value) {output(node.resolved_value)}
-      output(";")
+    output(":")
+    output(" ") unless node.style == :compressed || node.custom_property?
+    for_node(node, :value) do
+      output(if node.custom_property?
+               format_custom_property_value(node)
+             else
+               node.resolved_value
+             end)
     end
+    output(";") unless node.style == :compressed
   end
 
-  # @comment
-  #   rubocop:disable MethodLength
   def visit_rule(node)
     with_tabs(@tabs + node.tabs) do
       rule_separator = node.style == :compressed ? ',' : ', '
@@ -294,15 +290,15 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
                                       end
 
       joined_rules = node.resolved_rules.members.map do |seq|
-        next if seq.has_placeholder?
-        rule_part = seq.to_s(:style => node.style)
+        next if seq.invisible?
+        rule_part = seq.to_s(style: node.style, placeholder: false)
         if node.style == :compressed
           rule_part.gsub!(/([^,])\s*\n\s*/m, '\1 ')
           rule_part.gsub!(/\s*([+>])\s*/m, '\1')
           rule_part.gsub!(/nth([^( ]*)\(([^)]*)\)/m) do |match|
             match.tr(" \t\n", "")
           end
-          rule_part.strip!
+          rule_part = Sass::Util.strip_except_escapes(rule_part)
         end
         rule_part
       end.compact.join(rule_separator)
@@ -375,8 +371,6 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
       output("}" + trailer)
     end
   end
-  # @comment
-  #   rubocop:enable MethodLength
 
   def visit_keyframerule(node)
     visit_directive(node)
@@ -384,9 +378,42 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
   private
 
+  # Reformats the value of `node` so that it's nicely indented, preserving its
+  # existing relative indentation.
+  #
+  # @param node [Sass::Script::Tree::PropNode] A custom property node.
+  # @return [String]
+  def format_custom_property_value(node)
+    value = node.resolved_value.sub(/\n[ \t\r\f\n]*\Z/, ' ')
+    if node.style == :compact || node.style == :compressed || !value.include?("\n")
+      # Folding not involving newlines was done in the parser. We can safely
+      # fold newlines here because tokens like strings can't contain literal
+      # newlines, so we know any adjacent whitespace is tokenized as whitespace.
+      return node.resolved_value.gsub(/[ \t\r\f]*\n[ \t\r\f\n]*/, ' ')
+    end
+
+    # Find the smallest amount of indentation in the custom property and use
+    # that as the base indentation level.
+    lines = value.split("\n")
+    indented_lines = lines[1..-1]
+    min_indentation = indented_lines.
+      map {|line| line[/^[ \t]*/]}.
+      reject {|line| line.empty?}.
+      min_by {|line| line.length}
+
+    # Limit the base indentation to the same indentation level as the node name
+    # so that if *every* line is indented relative to the property name that's
+    # preserved.
+    if node.name_source_range
+      base_indentation = min_indentation[0...node.name_source_range.start_pos.offset - 1]
+    end
+
+    lines.first + "\n" + indented_lines.join("\n").gsub(/^#{base_indentation}/, '  ' * @tabs)
+  end
+
   def debug_info_rule(debug_info, options)
     node = Sass::Tree::DirectiveNode.resolved("@media -sass-debug-info")
-    Sass::Util.hash_to_a(debug_info.map {|k, v| [k.to_s, v.to_s]}).each do |k, v|
+    debug_info.map {|k, v| [k.to_s, v.to_s]}.to_a.each do |k, v|
       rule = Sass::Tree::RuleNode.new([""])
       rule.resolved_rules = Sass::Selector::CommaSequence.new(
         [Sass::Selector::Sequence.new(
@@ -395,7 +422,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
             false)
           ])
         ])
-      prop = Sass::Tree::PropNode.new([""], Sass::Script::Value::String.new(''), :new)
+      prop = Sass::Tree::PropNode.new([""], [""], :new)
       prop.resolved_name = "font-family"
       prop.resolved_value = Sass::SCSS::RX.escape_ident(v.to_s)
       rule << prop