oreorenasass 3.4.4 → 3.4.5

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

@@ -23,11 +23,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   def visit_children(parent)
     @tabs += 1
     return @format == :sass ? "\n" : " {}\n" if parent.children.empty?
-    if @format == :sass
-      "\n"  + super.join.rstrip + "\n"
-    else
-      " {\n" + super.join.rstrip + "\n#{ @tab_chars * (@tabs - 1)}}\n"
-    end
+    (@format == :sass ? "\n" : " {\n") + super.join.rstrip + (@format == :sass ? "\n" : "\n#{ @tab_chars * (@tabs-1)}}\n")
   ensure
     @tabs -= 1
   end
@@ -56,7 +52,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
   def visit_comment(node)
     value = interp_to_src(node.value)
-    if @format == :sass
+    content = if @format == :sass
       content = value.gsub(/\*\/$/, '').rstrip
       if content =~ /\A[ \t]/
         # Re-indent SCSS comments like this:
@@ -67,27 +63,31 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
         content.sub!(/\A([ \t]*)\/\*/, '/*\1')
       end
 
-      if content.include?("\n")
-        content.gsub!(/\n \*/, "\n  ")
-        spaces = content.scan(/\n( *)/).map {|s| s.first.size}.min
-        sep = node.type == :silent ? "\n//" : "\n *"
-        if spaces >= 2
-          content.gsub!(/\n  /, sep)
+      content =
+        unless content.include?("\n")
+          content
         else
-          content.gsub!(/\n#{' ' * spaces}/, sep)
+          content.gsub!(/\n( \*|\/\/)/, "\n  ")
+          spaces = content.scan(/\n( *)/).map {|s| s.first.size}.min
+          sep = node.type == :silent ? "\n//" : "\n *"
+          if spaces >= 2
+            content.gsub(/\n  /, sep)
+          else
+            content.gsub(/\n#{' ' * spaces}/, sep)
+          end
         end
-      end
 
       content.gsub!(/\A\/\*/, '//') if node.type == :silent
       content.gsub!(/^/, tab_str)
-      content = content.rstrip + "\n"
+      content.rstrip + "\n"
     else
       spaces = (@tab_chars * [@tabs - value[/^ */].size, 0].max)
       content = if node.type == :silent
-                  value.gsub(/^[\/ ]\*/, '//').gsub(/ *\*\/$/, '')
-                else
-                  value
-                end.gsub(/^/, spaces) + "\n"
+        value.gsub(/^[\/ ]\*/, '//').gsub(/ *\*\/$/, '')
+      else
+        value
+      end.gsub(/^/, spaces) + "\n"
+      content
     end
     content
   end
@@ -96,25 +96,19 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     "#{tab_str}@debug #{node.expr.to_sass(@options)}#{semi}\n"
   end
 
-  def visit_error(node)
-    "#{tab_str}@error #{node.expr.to_sass(@options)}#{semi}\n"
-  end
-
   def visit_directive(node)
     res = "#{tab_str}#{interp_to_src(node.value)}"
-    res.gsub!(/^@import \#\{(.*)\}([^}]*)$/, '@import \1\2')
+    res.gsub!(/^@import \#\{(.*)\}([^}]*)$/, '@import \1\2');
     return res + "#{semi}\n" unless node.has_children
     res + yield + "\n"
   end
 
   def visit_each(node)
-    vars = node.vars.map {|var| "$#{dasherize(var)}"}.join(", ")
-    "#{tab_str}@each #{vars} in #{node.list.to_sass(@options)}#{yield}"
+    "#{tab_str}@each $#{dasherize(node.var)} in #{node.list.to_sass(@options)}#{yield}"
   end
 
   def visit_extend(node)
-    "#{tab_str}@extend #{selector_to_src(node.selector).lstrip}#{semi}" +
-      "#{" !optional" if node.optional?}\n"
+    "#{tab_str}@extend #{selector_to_src(node.selector).lstrip}#{semi}#{" !optional" if node.optional?}\n"
   end
 
   def visit_for(node)
@@ -136,12 +130,9 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
   def visit_if(node)
     name =
-      if !@is_else
-        "if"
-      elsif node.expr
-        "else if"
-      else
-        "else"
+      if !@is_else; "if"
+      elsif node.expr; "else if"
+      else; "else"
       end
     @is_else = false
     str = "#{tab_str}@#{name}"
@@ -160,7 +151,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_media(node)
-    "#{tab_str}@media #{query_interp_to_src(node.query)}#{yield}"
+    "#{tab_str}@media #{media_interp_to_src(node.query)}#{yield}"
   end
 
   def visit_supports(node)
@@ -168,7 +159,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_cssimport(node)
-    if node.uri.is_a?(Sass::Script::Tree::Node)
+    if node.uri.is_a?(Sass::Script::Node)
       str = "#{tab_str}@import #{node.uri.to_sass(@options)}"
     else
       str = "#{tab_str}@import #{node.uri}"
@@ -205,24 +196,21 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   def visit_mixin(node)
     arg_to_sass = lambda do |arg|
       sass = arg.to_sass(@options)
-      sass = "(#{sass})" if arg.is_a?(Sass::Script::Tree::ListLiteral) && arg.separator == :comma
+      sass = "(#{sass})" if arg.is_a?(Sass::Script::List) && arg.separator == :comma
       sass
     end
 
     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]}"}
-
+      args = node.args.map(&arg_to_sass).join(", ")
+      keywords = Sass::Util.hash_to_a(node.keywords).
+        map {|k, v| "$#{dasherize(k)}: #{arg_to_sass[v]}"}.join(', ')
       if node.splat
-        splat = "#{arg_to_sass[node.splat]}..."
-        kwarg_splat = "#{arg_to_sass[node.kwarg_splat]}..." if node.kwarg_splat
+        splat = (args.empty? && keywords.empty?) ? "" : ", "
+        splat = "#{splat}#{arg_to_sass[node.splat]}..."
       end
-
-      arglist = "(#{[args, splat, keywords, kwarg_splat].flatten.compact.join(', ')})"
+      arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
     end
-    "#{tab_str}#{@format == :sass ? '+' : '@include '}" +
-      "#{dasherize(node.name)}#{arglist}#{node.has_children ? yield : semi}\n"
+    "#{tab_str}#{@format == :sass ? '+' : '@include '}#{dasherize(node.name)}#{arglist}#{node.has_children ? yield : semi}\n"
   end
 
   def visit_content(node)
@@ -240,13 +228,12 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_rule(node)
-    rule = node.parsed_rules ? [node.parsed_rules.to_s] : node.rule
     if @format == :sass
-      name = selector_to_sass(rule)
+      name = selector_to_sass(node.rule)
       name = "\\" + name if name[0] == ?:
       name.gsub(/^/, tab_str) + yield
     elsif @format == :scss
-      name = selector_to_scss(rule)
+      name = selector_to_scss(node.rule)
       res = name + yield
       if node.children.last.is_a?(Sass::Tree::CommentNode) && node.children.last.type == :silent
         res.slice!(-3..-1)
@@ -257,8 +244,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_variable(node)
-    "#{tab_str}$#{dasherize(node.name)}: #{node.expr.to_sass(@options)}" +
-      "#{' !global' if node.global}#{' !default' if node.guarded}#{semi}\n"
+    "#{tab_str}$#{dasherize(node.name)}: #{node.expr.to_sass(@options)}#{' !default' if node.guarded}#{semi}\n"
   end
 
   def visit_warn(node)
@@ -269,33 +255,29 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     "#{tab_str}@while #{node.expr.to_sass(@options)}#{yield}"
   end
 
-  def visit_atroot(node)
-    if node.query
-      "#{tab_str}@at-root #{query_interp_to_src(node.query)}#{yield}"
-    elsif node.children.length == 1 && node.children.first.is_a?(Sass::Tree::RuleNode)
-      rule = node.children.first
-      "#{tab_str}@at-root #{selector_to_src(rule.rule)}#{visit_children(rule)}"
-    else
-      "#{tab_str}@at-root#{yield}"
-    end
-  end
-
   private
 
   def interp_to_src(interp)
-    interp.map {|r| r.is_a?(String) ? r : r.to_sass(@options)}.join
+    interp.map do |r|
+      next r if r.is_a?(String)
+      "\#{#{r.to_sass(@options)}}"
+    end.join
   end
 
   # Like interp_to_src, but removes the unnecessary `#{}` around the keys and
-  # values in query expressions.
-  def query_interp_to_src(interp)
-    interp = interp.map do |e|
-      next e unless e.is_a?(Sass::Script::Tree::Literal)
-      next e unless e.value.is_a?(Sass::Script::Value::String)
-      e.value.value
-    end
-
-    interp_to_src(interp)
+  # values in media expressions.
+  def media_interp_to_src(interp)
+    Sass::Util.enum_with_index(interp).map do |r, i|
+      next r if r.is_a?(String)
+      before, after = interp[i-1], interp[i+1]
+      if before.is_a?(String) && after.is_a?(String) &&
+          ((before[-1] == ?( && after[0] == ?:) ||
+           (before =~ /:\s*/ && after[0] == ?)))
+        r.to_sass(@options)
+      else
+        "\#{#{r.to_sass(@options)}}"
+      end
+    end.join
   end
 
   def selector_to_src(sel)
@@ -307,7 +289,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
       if r.is_a?(String)
         r.gsub(/(,)?([ \t]*)\n\s*/) {$1 ? "#{$1}#{$2}\n" : " "}
       else
-        r.to_sass(@options)
+        "\#{#{r.to_sass(@options)}}"
       end
     end.join
   end

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

@@ -9,12 +9,10 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
 
   # Returns the immediate parent of the current node.
   # @return [Tree::Node]
-  def parent
-    @parents.last
-  end
+  attr_reader :parent
 
   def initialize
-    @parents = []
+    @parent_directives = []
     @extends = Sass::Util::SubsetMap.new
   end
 
@@ -29,19 +27,12 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   # Keeps track of the current parent node.
   def visit_children(parent)
     with_parent parent do
-      parent.children = visit_children_without_parent(parent)
+      parent.children = super.flatten
       parent
     end
   end
 
-  # Like {#visit\_children}, but doesn't set {#parent}.
-  #
-  # @param node [Sass::Tree::Node]
-  # @return [Array<Sass::Tree::Node>] the flattened results of
-  #   visiting all the children of `node`
-  def visit_children_without_parent(node)
-    node.children.map {|c| visit(c)}.flatten
-  end
+  MERGEABLE_DIRECTIVES = [Sass::Tree::MediaNode]
 
   # Runs a block of code with the current parent node
   # replaced with the given node.
@@ -50,10 +41,19 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   # @yield A block in which the parent is set to `parent`.
   # @return [Object] The return value of the block.
   def with_parent(parent)
-    @parents.push parent
+    if parent.is_a?(Sass::Tree::DirectiveNode)
+      if MERGEABLE_DIRECTIVES.any? {|klass| parent.is_a?(klass)}
+        old_parent_directive = @parent_directives.pop
+      end
+      @parent_directives.push parent
+    end
+
+    old_parent, @parent = @parent, parent
     yield
   ensure
-    @parents.pop
+    @parent_directives.pop if parent.is_a?(Sass::Tree::DirectiveNode)
+    @parent_directives.push old_parent_directive if old_parent_directive
+    @parent = old_parent
   end
 
   # In Ruby 1.8, ensures that there's only one `@charset` directive
@@ -106,7 +106,7 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   end
 
   # A simple struct wrapping up information about a single `@extend` instance. A
-  # single {ExtendNode} can have multiple Extends if either the parent node or
+  # single [ExtendNode] can have multiple Extends if either the parent node or
   # the extended selector is a comma sequence.
   #
   # @attr extender [Sass::Selector::Sequence]
@@ -123,23 +123,61 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
 
   # Registers an extension in the `@extends` subset map.
   def visit_extend(node)
-    parent.resolved_rules.populate_extends(@extends, node.resolved_selector, node,
-      @parents.select {|p| p.is_a?(Sass::Tree::DirectiveNode)})
+    node.resolved_selector.members.each do |seq|
+      if seq.members.size > 1
+        raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: can't extend nested selectors")
+      end
+
+      sseq = seq.members.first
+      if !sseq.is_a?(Sass::Selector::SimpleSequence)
+        raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: invalid selector")
+      elsif sseq.members.any? {|ss| ss.is_a?(Sass::Selector::Parent)}
+        raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: can't extend parent selectors")
+      end
+
+      sel = sseq.members
+      parent.resolved_rules.members.each do |member|
+        if !member.members.last.is_a?(Sass::Selector::SimpleSequence)
+          raise Sass::SyntaxError.new("#{member} can't extend: invalid selector")
+        end
+
+        @extends[sel] = Extend.new(member, sel, node, @parent_directives.dup, :not_found)
+      end
+    end
+
     []
   end
 
   # Modifies exception backtraces to include the imported file.
   def visit_import(node)
-    visit_children_without_parent(node)
+    # Don't use #visit_children to avoid adding the import node to the list of parents.
+    node.children.map {|c| visit(c)}.flatten
   rescue Sass::SyntaxError => e
     e.modify_backtrace(:filename => node.children.first.filename)
     e.add_backtrace(:filename => node.filename, :line => node.line)
     raise e
   end
 
+  # Bubbles the `@media` directive up through RuleNodes
+  # and merges it with other `@media` directives.
+  def visit_media(node)
+    yield unless bubble(node)
+    media = node.children.select {|c| c.is_a?(Sass::Tree::MediaNode)}
+    node.children.reject! {|c| c.is_a?(Sass::Tree::MediaNode)}
+    media = media.select {|n| n.resolved_query = n.resolved_query.merge(node.resolved_query)}
+    (node.children.empty? ? [] : [node]) + media
+  end
+
+  # Bubbles the `@supports` directive up through RuleNodes.
+  def visit_supports(node)
+    yield unless bubble(node)
+    node
+  end
+
   # Asserts that all the traced children are valid in their new location.
   def visit_trace(node)
-    visit_children_without_parent(node)
+    # Don't use #visit_children to avoid adding the trace node to the list of parents.
+    node.children.map {|c| visit(c)}.flatten
   rescue Sass::SyntaxError => e
     e.modify_backtrace(:mixin => node.name, :filename => node.filename, :line => node.line)
     e.add_backtrace(:filename => node.filename, :line => node.line)
@@ -165,38 +203,17 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     result
   end
 
-  def visit_atroot(node)
-    # If there aren't any more directives or rules that this @at-root needs to
-    # exclude, we can get rid of it and just evaluate the children.
-    if @parents.none? {|n| node.exclude_node?(n)}
-      results = visit_children_without_parent(node)
-      results.each {|c| c.tabs += node.tabs if bubblable?(c)}
-      if !results.empty? && bubblable?(results.last)
-        results.last.group_end = node.group_end
-      end
-      return results
-    end
-
-    # If this @at-root excludes the immediate parent, return it as-is so that it
-    # can be bubbled up by the parent node.
-    return Bubble.new(node) if node.exclude_node?(parent)
-
-    # Otherwise, duplicate the current parent and move it into the @at-root
-    # node. As above, returning an @at-root node signals to the parent directive
-    # that it should be bubbled upwards.
-    bubble(node)
-  end
-
-  # The following directives are visible and have children. This means they need
-  # to be able to handle bubbling up nodes such as @at-root and @media.
-
-  # Updates the indentation of the rule node based on the nesting
-  # level. The selectors were resolved in {Perform}.
+  # Resolves parent references and nested selectors,
+  # and updates the indentation of the rule node based on the nesting level.
   def visit_rule(node)
+    parent_resolved_rules = parent.is_a?(Sass::Tree::RuleNode) ? parent.resolved_rules : nil
+    # It's possible for resolved_rules to be set if we've duplicated this node during @media bubbling
+    node.resolved_rules ||= node.parsed_rules.resolve_parent_refs(parent_resolved_rules)
+
     yield
 
-    rules = node.children.select {|c| bubblable?(c)}
-    props = node.children.reject {|c| bubblable?(c) || c.invisible?}
+    rules = node.children.select {|c| c.is_a?(Sass::Tree::RuleNode) || c.bubbles?}
+    props = node.children.reject {|c| c.is_a?(Sass::Tree::RuleNode) || c.bubbles? || c.invisible?}
 
     unless props.empty?
       node.children = props
@@ -204,166 +221,21 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
       rules.unshift(node)
     end
 
-    rules = debubble(rules)
-    unless parent.is_a?(Sass::Tree::RuleNode) || rules.empty? || !bubblable?(rules.last)
-      rules.last.group_end = true
-    end
-    rules
-  end
-
-  def visit_keyframerule(node)
-    return node unless node.has_children
-
-    yield
-
-    debubble(node.children, node)
-  end
+    rules.last.group_end = true unless parent.is_a?(Sass::Tree::RuleNode) || rules.empty?
 
-  # Bubbles a directive up through RuleNodes.
-  def visit_directive(node)
-    return node unless node.has_children
-    return bubble(node) if parent.is_a?(Sass::Tree::RuleNode)
-
-    yield
-
-    # Since we don't know if the mere presence of an unknown directive may be
-    # important, we should keep an empty version around even if all the contents
-    # are removed via @at-root. However, if the contents are just bubbled out,
-    # we don't need to do so.
-    directive_exists = node.children.any? do |child|
-      next true unless child.is_a?(Bubble)
-      next false unless child.node.is_a?(Sass::Tree::DirectiveNode)
-      child.node.resolved_value == node.resolved_value
-    end
-
-    # We know empty @keyframes directives do nothing.
-    if directive_exists || node.name == '@keyframes'
-      []
-    else
-      empty_node = node.dup
-      empty_node.children = []
-      [empty_node]
-    end + debubble(node.children, node)
-  end
-
-  # Bubbles the `@media` directive up through RuleNodes
-  # and merges it with other `@media` directives.
-  def visit_media(node)
-    return bubble(node) if parent.is_a?(Sass::Tree::RuleNode)
-    return Bubble.new(node) if parent.is_a?(Sass::Tree::MediaNode)
-
-    yield
-
-    debubble(node.children, node) do |child|
-      next child unless child.is_a?(Sass::Tree::MediaNode)
-      # Copies of `node` can be bubbled, and we don't want to merge it with its
-      # own query.
-      next child if child.resolved_query == node.resolved_query
-      next child if child.resolved_query = child.resolved_query.merge(node.resolved_query)
-    end
-  end
-
-  # Bubbles the `@supports` directive up through RuleNodes.
-  def visit_supports(node)
-    return node unless node.has_children
-    return bubble(node) if parent.is_a?(Sass::Tree::RuleNode)
-
-    yield
-
-    debubble(node.children, node)
+    rules
   end
 
   private
 
-  # "Bubbles" `node` one level by copying the parent and wrapping `node`'s
-  # children with it.
-  #
-  # @param node [Sass::Tree::Node].
-  # @return [Bubble]
   def bubble(node)
+    return unless parent.is_a?(Sass::Tree::RuleNode)
     new_rule = parent.dup
     new_rule.children = node.children
-    node.children = [new_rule]
-    Bubble.new(node)
-  end
-
-  # Pops all bubbles in `children` and intersperses the results with the other
-  # values.
-  #
-  # If `parent` is passed, it's copied and used as the parent node for the
-  # nested portions of `children`.
-  #
-  # @param children [List<Sass::Tree::Node, Bubble>]
-  # @param parent [Sass::Tree::Node]
-  # @yield [node] An optional block for processing bubbled nodes. Each bubbled
-  #   node will be passed to this block.
-  # @yieldparam node [Sass::Tree::Node] A bubbled node.
-  # @yieldreturn [Sass::Tree::Node?] A node to use in place of the bubbled node.
-  #   This can be the node itself, or `nil` to indicate that the node should be
-  #   omitted.
-  # @return [List<Sass::Tree::Node, Bubble>]
-  def debubble(children, parent = nil)
-    # Keep track of the previous parent so that we don't divide `parent`
-    # unnecessarily if the `@at-root` doesn't produce any new nodes (e.g.
-    # `@at-root {@extend %foo}`).
-    previous_parent = nil
-
-    Sass::Util.slice_by(children) {|c| c.is_a?(Bubble)}.map do |(is_bubble, slice)|
-      unless is_bubble
-        next slice unless parent
-        if previous_parent
-          previous_parent.children.push(*slice)
-          next []
-        else
-          previous_parent = new_parent = parent.dup
-          new_parent.children = slice
-          next new_parent
-        end
-      end
-
-      slice.map do |bubble|
-        next unless (node = block_given? ? yield(bubble.node) : bubble.node)
-        node.tabs += bubble.tabs
-        node.group_end = bubble.group_end
-        results = [visit(node)].flatten
-        previous_parent = nil unless results.empty?
-        results
-      end.compact
-    end.flatten
-  end
-
-  # Returns whether or not a node can be bubbled up through the syntax tree.
-  #
-  # @param node [Sass::Tree::Node]
-  # @return [Boolean]
-  def bubblable?(node)
-    node.is_a?(Sass::Tree::RuleNode) || node.bubbles?
-  end
-
-  # A wrapper class for a node that indicates to the parent that it should
-  # treat the wrapped node as a sibling rather than a child.
-  #
-  # Nodes should be wrapped before they're passed to \{Cssize.visit}. They will
-  # be automatically visited upon calling \{#pop}.
-  #
-  # This duck types as a [Sass::Tree::Node] for the purposes of
-  # tree-manipulation operations.
-  class Bubble
-    attr_accessor :node
-    attr_accessor :tabs
-    attr_accessor :group_end
-
-    def initialize(node)
-      @node = node
-      @tabs = 0
-    end
-
-    def bubbles?
-      true
-    end
-
-    def inspect
-      "(Bubble #{node.inspect})"
-    end
+    node.children = with_parent(node) {Array(visit(new_rule))}
+    # If the last child is actually the end of the group,
+    # the parent's cssize will set it properly
+    node.children.last.group_end = false unless node.children.empty?
+    true
   end
 end