sass 3.3.0.rc.2 → 3.3.0.rc.3

data/lib/sass/source/map.rb

@@ -94,9 +94,9 @@ module Sass::Source
     #   rubocop:disable MethodLength
     def to_json(options)
       css_uri, css_path, sourcemap_path =
-        [:css_uri, :css_path, :sourcemap_path].map {|o| options[o]}
+        options[:css_uri], options[:css_path], options[:sourcemap_path]
       unless css_uri || (css_path && sourcemap_path)
-        raise ArgumentError.new("Sass::Source::Map#to_json requires either " +
+        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 &&= Pathname.pwd.join(Pathname.new(css_path)).cleanpath
@@ -111,7 +111,6 @@ module Sass::Source
       next_source_id = 0
       line_data = []
       segment_data_for_line = []
-      no_public_url = Set.new
 
       # These track data necessary for the delta coding.
       previous_target_line = nil
@@ -122,22 +121,9 @@ module Sass::Source
 
       @data.each do |m|
         file, importer = m.input.file, m.input.importer
-        unless (source_uri = importer && importer.public_url(file))
-          if importer.is_a?(Sass::Importers::Filesystem) && sourcemap_path
-            file_path = Pathname.new(importer.root).join(file)
-            source_uri = file_path.relative_path_from(sourcemap_path.dirname).to_s
-          elsif no_public_url.include?(file)
-            next
-          else
-            no_public_url << file
-            Sass::Util.sass_warn <<WARNING
-WARNING: Couldn't determine public URL for "#{file}" while generating sourcemap.
-  Without a public URL, there's nothing for the source map to link to.
-  Custom importers should define the #public_url method.
-WARNING
-            next
-          end
-        end
+        source_uri = importer &&
+          importer.public_url(file, sourcemap_path && sourcemap_path.dirname.to_s)
+        next unless source_uri
 
         current_source_id = source_uri_to_id[source_uri]
         unless current_source_id
@@ -190,6 +176,7 @@ WARNING
       source_names = []
       (0...next_source_id).each {|id| source_names.push(id_to_source_uri[id].to_s)}
       write_json_field(result, "sources", source_names)
+      write_json_field(result, "names", [])
       write_json_field(result, "file", css_uri)
 
       result << "\n}"

data/lib/sass/tree/at_root_node.rb

@@ -70,7 +70,7 @@ module Sass
       # @return [Boolean]
       def exclude_node?(node)
         return exclude?(node.name.gsub(/^@/, '')) if node.is_a?(Sass::Tree::DirectiveNode)
-        exclude?(node.class.to_s.gsub(/.*::(.*)Node$/, '\1').downcase)
+        exclude?('rule') && node.is_a?(Sass::Tree::RuleNode)
       end
 
       # @see Node#bubbles?

data/lib/sass/tree/mixin_node.rb

@@ -16,7 +16,7 @@ module Sass::Tree
     attr_accessor :args
 
     # A hash from keyword argument names to values.
-    # @return [{String => Script::Tree::Node}]
+    # @return [Sass::Util::NormalizedMap<Script::Tree::Node>]
     attr_accessor :keywords
 
     # The first splat argument for this mixin, if one exists.
@@ -39,7 +39,7 @@ module Sass::Tree
     # @param args [Array<Script::Tree::Node>] See \{#args}
     # @param splat [Script::Tree::Node] See \{#splat}
     # @param kwarg_splat [Script::Tree::Node] See \{#kwarg_splat}
-    # @param keywords [{String => Script::Tree::Node}] See \{#keywords}
+    # @param keywords [Sass::Util::NormalizedMap<Script::Tree::Node>] See \{#keywords}
     def initialize(name, args, keywords, splat, kwarg_splat)
       @name = name
       @args = args

data/lib/sass/tree/prop_node.rb

@@ -166,7 +166,6 @@ module Sass::Tree
 
         Sass::Script::Value::String.new("(#{node.to_sass(opts)})")
       end
-
     end
   end
 end

data/lib/sass/tree/variable_node.rb

@@ -20,11 +20,6 @@ module Sass
       # @return [Boolean]
       attr_reader :global
 
-      # Whether we've warned about deprecated global variable
-      # assignment yet for this node.
-      # @return [Boolean]
-      attr_accessor :global_warning_given
-
       # @param name [String] The name of the variable
       # @param expr [Script::Tree::Node] See \{#expr}
       # @param guarded [Boolean] See \{#guarded}

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

@@ -1,6 +1,5 @@
 # A visitor for checking that all nodes are properly nested.
 class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
-
   protected
 
   def initialize

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

@@ -68,7 +68,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
       end
 
       if content.include?("\n")
-        content.gsub!(%r{\n( \*|//)}, "\n  ")
+        content.gsub!(/\n \*/, "\n  ")
         spaces = content.scan(/\n( *)/).map {|s| s.first.size}.min
         sep = node.type == :silent ? "\n//" : "\n *"
         if spaces >= 2
@@ -207,7 +207,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).
+      keywords = Sass::Util.hash_to_a(node.keywords.as_stored).
         map {|k, v| "$#{dasherize(k)}: #{arg_to_sass[v]}"}
 
       if node.splat

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

@@ -9,10 +9,12 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
 
   # Returns the immediate parent of the current node.
   # @return [Tree::Node]
-  attr_reader :parent
+  def parent
+    @parents.last
+  end
 
   def initialize
-    @parent_directives = []
+    @parents = []
     @extends = Sass::Util::SubsetMap.new
   end
 
@@ -41,8 +43,6 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     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,19 +50,10 @@ 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)
-    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
+    @parents.push parent
     yield
   ensure
-    @parent_directives.pop if parent.is_a?(Sass::Tree::DirectiveNode)
-    @parent_directives.push old_parent_directive if old_parent_directive
-    @parent = old_parent
+    @parents.pop
   end
 
   # In Ruby 1.8, ensures that there's only one `@charset` directive
@@ -82,17 +73,29 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
         node.children.unshift charset if charset
       end
 
-      imports = Sass::Util.extract!(node.children) do |c|
-        c.is_a?(Sass::Tree::DirectiveNode) && !c.is_a?(Sass::Tree::MediaNode) &&
-          c.resolved_value =~ /^@import /i
+      imports_to_move = []
+      import_limit = nil
+      i = -1
+      node.children.reject! do |n|
+        i += 1
+        if import_limit
+          next false unless n.is_a?(Sass::Tree::CssImportNode)
+          imports_to_move << n
+          next true
+        end
+
+        if !n.is_a?(Sass::Tree::CommentNode) &&
+            !n.is_a?(Sass::Tree::CharsetNode) &&
+            !n.is_a?(Sass::Tree::CssImportNode)
+          import_limit = i
+        end
+
+        false
       end
-      charset_and_index = Sass::Util.ruby1_8? &&
-        node.children.each_with_index.find {|c, _| c.is_a?(Sass::Tree::CharsetNode)}
-      if charset_and_index
-        index = charset_and_index.last
-        node.children = node.children[0..index] + imports + node.children[index + 1..-1]
-      else
-        node.children = imports + node.children
+
+      if import_limit
+        node.children = node.children[0...import_limit] + imports_to_move +
+          node.children[import_limit..-1]
       end
     end
 
@@ -138,7 +141,8 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
           raise Sass::SyntaxError.new("#{member} can't extend: invalid selector")
         end
 
-        @extends[sel] = Extend.new(member, sel, node, @parent_directives.dup, :not_found)
+        parent_directives = @parents.select {|p| p.is_a?(Sass::Tree::DirectiveNode)}
+        @extends[sel] = Extend.new(member, sel, node, parent_directives, :not_found)
       end
     end
 
@@ -154,31 +158,6 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     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)
-
-    bubbled = node.children.select do |n|
-      n.is_a?(Sass::Tree::AtRootNode) || n.is_a?(Sass::Tree::MediaNode)
-    end
-    node.children -= bubbled
-
-    bubbled = bubbled.map do |n|
-      next visit(n) if n.is_a?(Sass::Tree::AtRootNode)
-      # Otherwise, n should be a MediaNode.
-      next [] unless n.resolved_query = n.resolved_query.merge(node.resolved_query)
-      n
-    end.flatten
-
-    (node.children.empty? ? [] : [node]) + bubbled
-  end
-
-  # Bubbles the `@supports` directive up through RuleNodes.
-  def visit_supports(node)
-    visit_directive(node) {yield}
-  end
-
   # Asserts that all the traced children are valid in their new location.
   def visit_trace(node)
     visit_children_without_parent(node)
@@ -188,16 +167,6 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     raise e
   end
 
-  # Bubbles a directive up through RuleNodes.
-  def visit_directive(node)
-    return yield unless node.has_children
-    yield unless (bubbled = bubble(node))
-    at_roots = node.children.select {|n| n.is_a?(Sass::Tree::AtRootNode)}
-    node.children -= at_roots
-    at_roots.map! {|n| visit(n)}.flatten
-    (bubbled && node.children.empty? ? [] : [node]) + at_roots
-  end
-
   # Converts nested properties into flat properties
   # and updates the indentation of the prop node based on the nesting level.
   def visit_prop(node)
@@ -217,15 +186,38 @@ 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}.
   def visit_rule(node)
     yield
 
-    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?}
-
-    rules.map {|c| c.is_a?(Sass::Tree::AtRootNode) ? visit(c) : c}.flatten
+    rules = node.children.select {|c| bubblable?(c)}
+    props = node.children.reject {|c| bubblable?(c) || c.invisible?}
 
     unless props.empty?
       node.children = props
@@ -233,37 +225,145 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
       rules.unshift(node)
     end
 
-    rules.last.group_end = true unless parent.is_a?(Sass::Tree::RuleNode) || rules.empty?
-
+    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_atroot(node)
-    if @parent_directives.any? {|n| node.exclude_node?(n)}
-      return node if node.exclude_node?(parent)
+  # 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
+
+    if directive_exists
+      []
+    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
 
-      new_rule = parent.dup
-      new_rule.children = node.children
-      node.children = [new_rule]
-      return node
+    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)
 
-    results = visit_children_without_parent(node)
-    results.each {|n| n.tabs += node.tabs}
-    results.last.group_end = node.group_end unless results.empty?
-    results
+    yield
+
+    debubble(node.children, node)
   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 = 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
+    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)
+    Sass::Util.slice_by(children) {|c| c.is_a?(Bubble)}.map do |(is_bubble, slice)|
+      unless is_bubble
+        next slice unless parent
+        new_parent = parent.dup
+        new_parent.children = slice
+        next new_parent
+      end
+
+      next slice.map do |bubble|
+        next unless (node = block_given? ? yield(bubble.node) : bubble.node)
+        node.tabs += bubble.tabs
+        node.group_end = bubble.group_end
+        [visit(node)].flatten
+      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
   end
 end