sass 3.4.25 → 3.7.4

data/lib/sass/selector/simple_sequence.rb

@@ -163,7 +163,7 @@ module Sass
           next sel if seen.include?([sel])
           extended = sel.selector.do_extend(extends, parent_directives, replace, seen, false)
           next sel if extended == sel.selector
-          extended.members.reject! {|seq| seq.has_placeholder?}
+          extended.members.reject! {|seq| seq.invisible?}
 
           # For `:not()`, we usually want to get rid of any complex
           # selectors because that will cause the selector to fail to
@@ -184,17 +184,16 @@ module Sass
           result
         end.flatten
 
-        groups = Sass::Util.group_by_to_a(extends[members.to_set]) {|ex| ex.extender}
+        groups = extends[members.to_set].group_by {|ex| ex.extender}.to_a
         groups.map! do |seq, group|
           sels = group.map {|e| e.target}.flatten
           # If A {@extend B} and C {...},
           # seq is A, sels is B, and self is C
 
           self_without_sel = Sass::Util.array_minus(members, sels)
-          group.each {|e| e.result = :failed_to_unify unless e.result == :succeeded}
+          group.each {|e| e.success = true}
           unified = seq.members.last.unify(SimpleSequence.new(self_without_sel, subject?))
           next unless unified
-          group.each {|e| e.result = :succeeded}
           group.each {|e| check_directives_match!(e, parent_directives)}
           new_seq = Sequence.new(seq.members[0...-1] + [unified])
           new_seq.add_sources!(sources + [seq])
@@ -287,6 +286,11 @@ module Sass
       # @see Simple#to_s
       def to_s(opts = {})
         res = @members.map {|m| m.to_s(opts)}.join
+
+        # :not(%foo) may resolve to the empty string, but it should match every
+        # selector so we replace it with "*".
+        res = '*' if res.empty?
+
         res << '!' if subject?
         res
       end

data/lib/sass/source/map.rb

@@ -84,8 +84,6 @@ module Sass::Source
     # @return [String] The JSON string.
     # @raise [ArgumentError] If neither `:css_uri` nor `:css_path` and
     #   `:sourcemap_path` are specified.
-    # @comment
-    #   rubocop:disable MethodLength
     def to_json(options)
       css_uri, css_path, sourcemap_path =
         options[:css_uri], options[:css_path], options[:sourcemap_path]
@@ -93,8 +91,8 @@ module Sass::Source
         raise ArgumentError.new("Sass::Source::Map#to_json requires either " \
           "the :css_uri option or both the :css_path and :soucemap_path options.")
       end
-      css_path &&= Sass::Util.pathname(Sass::Util.absolute_path(css_path))
-      sourcemap_path &&= Sass::Util.pathname(Sass::Util.absolute_path(sourcemap_path))
+      css_path &&= Sass::Util.pathname(File.absolute_path(css_path))
+      sourcemap_path &&= Sass::Util.pathname(File.absolute_path(sourcemap_path))
       css_uri ||= Sass::Util.file_uri_from_path(
         Sass::Util.relative_path_from(css_path, sourcemap_path.dirname))
 
@@ -197,8 +195,6 @@ module Sass::Source
       result << "\n}"
       result
     end
-    # @comment
-    #   rubocop:enable MethodLength
 
     private
 

data/lib/sass/stack.rb

@@ -98,8 +98,28 @@ module Sass
       with_frame(filename, line, :mixin, name) {yield}
     end
 
+    # Pushes a function frame onto the stack.
+    #
+    # @param filename [String] See \{Frame#filename}.
+    # @param line [String] See \{Frame#line}.
+    # @param name [String] See \{Frame#name}.
+    # @yield [] A block in which the new frame is on the stack.
+    def with_function(filename, line, name)
+      with_frame(filename, line, :function, name) {yield}
+    end
+
+    # Pushes a function frame onto the stack.
+    #
+    # @param filename [String] See \{Frame#filename}.
+    # @param line [String] See \{Frame#line}.
+    # @param name [String] See \{Frame#name}.
+    # @yield [] A block in which the new frame is on the stack.
+    def with_directive(filename, line, name)
+      with_frame(filename, line, :directive, name) {yield}
+    end
+
     def to_s
-      Sass::Util.enum_with_index(Sass::Util.enum_cons(frames.reverse + [nil], 2)).
+      (frames.reverse + [nil]).each_cons(2).each_with_index.
           map do |(frame, caller), i|
         "#{i == 0 ? 'on' : 'from'} line #{frame.line}" +
           " of #{frame.filename || 'an unknown file'}" +

data/lib/sass/tree/charset_node.rb

@@ -16,7 +16,7 @@ module Sass::Tree
 
     # @see Node#invisible?
     def invisible?
-      !Sass::Util.ruby1_8?
+      true
     end
   end
 end

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
@@ -138,13 +139,10 @@ 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 = nil
-      warnings = Sass::Util.silence_warnings do
-        parser = Sass::SCSS::StaticParser.new(@rule.join.strip, nil, nil, 1)
-        # rubocop:disable RescueModifier
+      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
-        # rubocop:enable RescueModifier
-
-        $stderr.string
       end
 
       # If parsing produces a warning, throw away the result so we can parse

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

@@ -61,7 +61,7 @@ class Sass::Tree::Visitors::DeepCopy < Sass::Tree::Visitors::Base
 
   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

@@ -11,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}"
@@ -145,8 +143,6 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
       end
     end
   end
-  # @comment
-  #   rubocop:enable MethodLength
 
   protected
 
@@ -290,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
 
@@ -341,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
 
@@ -351,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
 
@@ -395,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
 
@@ -483,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
 
@@ -545,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)
@@ -556,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)