sass 3.2.0.alpha.11 → 3.2.0.alpha.21

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

@@ -175,7 +175,11 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
       keywords = node.keywords.map {|k, v| "$#{dasherize(k)}: #{v.to_sass(@options)}"}.join(', ')
       arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
     end
-    "#{tab_str}#{@format == :sass ? '+' : '@include '}#{dasherize(node.name)}#{arglist}#{semi}\n"
+    "#{tab_str}#{@format == :sass ? '+' : '@include '}#{dasherize(node.name)}#{arglist}#{node.has_children ? yield : semi}\n"
+  end
+
+  def visit_content(node)
+    "#{tab_str}@content#{semi}\n"
   end
 
   def visit_prop(node)

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

@@ -121,9 +121,9 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     (node.children.empty? ? [] : [node]) + media
   end
 
-  # Asserts that all the mixin's children are valid in their new location.
-  def visit_mixin(node)
-    # Don't use #visit_children to avoid adding the mixin node to the list of parents.
+  # Asserts that all the traced children are valid in their new location.
+  def visit_trace(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)

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

@@ -0,0 +1,87 @@
+# A visitor for copying the full structure of a Sass tree.
+class Sass::Tree::Visitors::DeepCopy < Sass::Tree::Visitors::Base
+  protected
+
+  def visit(node)
+    super(node.dup)
+  end
+
+  def visit_children(parent)
+    parent.children = parent.children.map {|c| visit(c)}
+    parent
+  end
+
+  def visit_debug(node)
+    node.expr = node.expr.deep_copy
+    yield
+  end
+
+  def visit_each(node)
+    node.list = node.list.deep_copy
+    yield
+  end
+
+  def visit_extend(node)
+    node.selector = node.selector.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c}
+    yield
+  end
+
+  def visit_for(node)
+    node.from = node.from.deep_copy
+    node.to = node.to.deep_copy
+    yield
+  end
+
+  def visit_function(node)
+    node.args = node.args.map {|k, v| [k.deep_copy, v && v.deep_copy]}
+    yield
+  end
+
+  def visit_if(node)
+    node.expr = node.expr.deep_copy if node.expr
+    node.else = visit(node.else) if node.else
+    yield
+  end
+
+  def visit_mixin_def(node)
+    node.args = node.args.map {|k, v| [k.deep_copy, v && v.deep_copy]}
+    yield
+  end
+
+  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]}]
+    yield
+  end
+
+  def visit_prop(node)
+    node.name = node.name.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c}
+    node.value = node.value.deep_copy
+    yield
+  end
+
+  def visit_return(node)
+    node.expr = node.expr.deep_copy
+    yield
+  end
+
+  def visit_rule(node)
+    node.rule = node.rule.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c}
+    yield
+  end
+
+  def visit_variable(node)
+    node.expr = node.expr.deep_copy
+    yield
+  end
+
+  def visit_warn(node)
+    node.expr = node.expr.deep_copy
+    yield
+  end
+
+  def visit_while(node)
+    node.expr = node.expr.deep_copy
+    yield
+  end
+end

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

@@ -13,7 +13,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     @environment = env
   end
 
-  # If an exception is raised, this add proper metadata to the backtrace.
+  # If an exception is raised, this adds proper metadata to the backtrace.
   def visit(node)
     super(node.dup)
   rescue Sass::SyntaxError => e
@@ -89,8 +89,8 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Runs SassScript interpolation in the selector,
   # and then parses the result into a {Sass::Selector::CommaSequence}.
   def visit_extend(node)
-    parser = Sass::SCSS::CssParser.new(run_interp(node.selector), node.line)
-    node.resolved_selector = parser.parse_selector(node.filename)
+    parser = Sass::SCSS::CssParser.new(run_interp(node.selector), node.filename, node.line)
+    node.resolved_selector = parser.parse_selector
     node
   end
 
@@ -116,7 +116,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Loads the function into the environment.
   def visit_function(node)
     @environment.set_function(node.name,
-      Sass::Callable.new(node.name, node.args, @environment, node.children))
+      Sass::Callable.new(node.name, node.args, @environment, node.children, !:has_content))
     []
   end
 
@@ -155,7 +155,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Loads a mixin into the environment.
   def visit_mixindef(node)
     @environment.set_mixin(node.name,
-      Sass::Callable.new(node.name, node.args, @environment, node.children))
+      Sass::Callable.new(node.name, node.args, @environment, node.children, node.has_content))
     []
   end
 
@@ -168,6 +168,10 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     original_env.prepare_frame(:mixin => node.name)
     raise Sass::SyntaxError.new("Undefined mixin '#{node.name}'.") unless mixin = @environment.mixin(node.name)
 
+    if node.children.any? && !mixin.has_content
+      raise Sass::SyntaxError.new(%Q{Mixin "#{node.name}" does not accept a content block.})
+    end
+
     passed_args = node.args.dup
     passed_keywords = node.keywords.dup
 
@@ -196,9 +200,12 @@ END
       raise Sass::SyntaxError.new("Mixin #{node.name} is missing parameter #{var.inspect}.") unless env.var(var.name)
       env
     end
+    environment.caller = Sass::Environment.new(original_env)
+    environment.content = node.children if node.has_children
 
-    with_environment(environment) {node.children = mixin.tree.map {|c| visit(c)}.flatten}
-    node
+    trace_node = Sass::Tree::TraceNode.from_node(node.name, node)
+    with_environment(environment) {trace_node.children = mixin.tree.map {|c| visit(c)}.flatten}
+    trace_node
   rescue Sass::SyntaxError => e
     if original_env # Don't add backtrace info if this is an @include loop
       e.modify_backtrace(:mixin => node.name, :line => node.line)
@@ -209,6 +216,17 @@ END
     original_env.pop_frame if original_env
   end
 
+  def visit_content(node)
+    raise Sass::SyntaxError.new("No @content passed.") unless content = @environment.content
+    trace_node = Sass::Tree::TraceNode.from_node('@content', node)
+    with_environment(@environment.caller) {trace_node.children = content.map {|c| visit(c.dup)}.flatten}
+    trace_node
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:mixin => '@content', :line => node.line)
+    e.add_backtrace(:line => node.line)
+    raise e
+  end
+
   # Runs any SassScript that may be embedded in a property.
   def visit_prop(node)
     node.resolved_name = run_interp(node.name)
@@ -225,8 +243,13 @@ END
   # Runs SassScript interpolation in the selector,
   # and then parses the result into a {Sass::Selector::CommaSequence}.
   def visit_rule(node)
-    parser = Sass::SCSS::StaticParser.new(run_interp(node.rule), node.line)
-    node.parsed_rules ||= parser.parse_selector(node.filename)
+    parser = Sass::SCSS::StaticParser.new(run_interp(node.rule), node.filename, node.line)
+    node.parsed_rules ||= parser.parse_selector
+    if node.options[:trace_selectors]
+      @environment.push_frame(:filename => node.filename, :line => node.line)
+      node.stack_trace = @environment.stack_trace
+      @environment.pop_frame
+    end
     yield
   end
 
@@ -243,13 +266,10 @@ END
     @environment.push_frame(:filename => node.filename, :line => node.line)
     res = node.expr.perform(@environment)
     res = res.value if res.is_a?(Sass::Script::String)
-    msg = "WARNING: #{res}\n"
-    @environment.stack.reverse.each_with_index do |entry, i|
-      msg << "        #{i == 0 ? "on" : "from"} line #{entry[:line]}" <<
-        " of #{entry[:filename] || "an unknown file"}"
-      msg << ", in `#{entry[:mixin]}'" if entry[:mixin]
-      msg << "\n"
-    end
+    msg = "WARNING: #{res}\n         "
+    msg << @environment.stack_trace.join("\n         ")
+    # JRuby doesn't automatically add a newline for #warn
+    msg << (RUBY_PLATFORM =~ /java/ ? "\n\n" : "\n")
     Sass::Util.sass_warn msg
     []
   ensure

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

@@ -0,0 +1,97 @@
+# A visitor for setting options on the Sass tree
+class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
+  # @param root [Tree::Node] The root node of the tree to visit.
+  # @param options [{Symbol => Object}] The options has to set.
+  def self.visit(root, options); new(options).send(:visit, root); end
+
+  protected
+
+  def initialize(options)
+    @options = options
+  end
+
+  def visit(node)
+    node.instance_variable_set('@options', @options)
+    super
+  end
+
+  def visit_debug(node)
+    node.expr.options = @options
+    yield
+  end
+
+  def visit_each(node)
+    node.list.options = @options
+    yield
+  end
+
+  def visit_extend(node)
+    node.selector.each {|c| c.options = @options if c.is_a?(Sass::Script::Node)}
+    yield
+  end
+
+  def visit_for(node)
+    node.from.options = @options
+    node.to.options = @options
+    yield
+  end
+
+  def visit_function(node)
+    node.args.each do |k, v|
+      k.options = @options
+      v.options = @options if v
+    end
+    yield
+  end
+
+  def visit_if(node)
+    node.expr.options = @options if node.expr
+    visit(node.else) if node.else
+    yield
+  end
+
+  def visit_mixin_def(node)
+    node.args.each do |k, v|
+      k.options = @options
+      v.options = @options if v
+    end
+    yield
+  end
+
+  def visit_mixin(node)
+    node.args.each {|a| a.options = @options}
+    node.keywords.each {|k, v| v.options = @options}
+    yield
+  end
+
+  def visit_prop(node)
+    node.name.each {|c| c.options = @options if c.is_a?(Sass::Script::Node)}
+    node.value.options = @options
+    yield
+  end
+
+  def visit_return(node)
+    node.expr.options = @options
+    yield
+  end
+
+  def visit_rule(node)
+    node.rule.each {|c| c.options = @options if c.is_a?(Sass::Script::Node)}
+    yield
+  end
+
+  def visit_variable(node)
+    node.expr.options = @options
+    yield
+  end
+
+  def visit_warn(node)
+    node.expr.options = @options
+    yield
+  end
+
+  def visit_while(node)
+    node.expr.options = @options
+    yield
+  end
+end

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

@@ -156,6 +156,10 @@ MESSAGE
       if node.style != :compressed
         if node.options[:debug_info]
           to_return << visit(debug_info_rule(node.debug_info, node.options)) << "\n"
+        elsif node.options[:trace_selectors]
+          to_return << "#{old_spaces}/* "
+          to_return << node.stack_trace.join("\n   #{old_spaces}")
+          to_return << " */\n"
         elsif node.options[:line_comments]
           to_return << "#{old_spaces}/* line #{node.line}"
 
@@ -204,7 +208,7 @@ MESSAGE
                 [Sass::Selector::Element.new(k.to_s.gsub(/[^\w-]/, "\\\\\\0"), nil)])
             ])
         ])
-      prop = Sass::Tree::PropNode.new([""], "", :new)
+      prop = Sass::Tree::PropNode.new([""], Sass::Script::String.new(''), :new)
       prop.resolved_name = "font-family"
       prop.resolved_value = Sass::SCSS::RX.escape_ident(v.to_s)
       rule << prop

data/lib/sass/tree/warn_node.rb

@@ -6,19 +6,13 @@ module Sass
     class WarnNode < Node
       # The expression to print.
       # @return [Script::Node]
-      attr_reader :expr
+      attr_accessor :expr
 
       # @param expr [Script::Node] The expression to print
       def initialize(expr)
         @expr = expr
         super()
       end
-
-      # Returns sub nodes that are not tree children.
-      def subnodes
-        Array(expr)
-      end
-
     end
   end
 end

data/lib/sass/tree/while_node.rb

@@ -7,18 +7,12 @@ module Sass::Tree
   class WhileNode < Node
     # The parse tree for the continuation expression.
     # @return [Script::Node]
-    attr_reader :expr
+    attr_accessor :expr
 
     # @param expr [Script::Node] See \{#expr}
     def initialize(expr)
       @expr = expr
       super()
     end
-
-    # Returns sub nodes that are not tree children.
-    def subnodes
-      Array(expr)
-    end
-
   end
 end

data/test/sass/cache_test.rb

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/test_helper'
 require 'sass/engine'
 
 class CacheTest < Test::Unit::TestCase
@@ -11,6 +12,7 @@ class CacheTest < Test::Unit::TestCase
 
   def teardown
     FileUtils.rm_rf @@cache_dir
+    clean_up_sassc
   end
 
   def test_file_cache_writes_a_file
@@ -64,6 +66,19 @@ class CacheTest < Test::Unit::TestCase
     assert_equal an_object, cache.retrieve("an_object", "")
   end
 
+  class Unmarshalable
+    def _dump(_)
+      raise 'Unmarshalable'
+    end
+  end
+
+  def test_cache_node_with_unmarshalable_option
+    engine = Sass::Engine.new("foo {a: b + c}",
+      :syntax => :scss, :object => Unmarshalable.new, :filename => 'file.scss',
+      :importer => Sass::Importers::Filesystem.new(absolutize('templates')))
+    engine.to_tree
+  end
+
   private
   def root_node
     Sass::Engine.new(<<-SCSS, :syntax => :scss).to_tree

data/test/sass/conversion_test.rb

@@ -1152,6 +1152,44 @@ SASS
 SCSS
   end
 
+  def test_content_conversion
+    assert_renders(<<SASS, <<SCSS)
+$color: blue
+
+=context($class, $color: red)
+  .\#{$class}
+    background-color: $color
+    @content
+    border-color: $color
+
++context(parent)
+  +context(child, $color: yellow)
+    color: $color
+SASS
+$color: blue;
+
+@mixin context($class, $color: red) {
+  .\#{$class} {
+    background-color: $color;
+    @content;
+    border-color: $color; } }
+
+@include context(parent) {
+  @include context(child, $color: yellow) {
+    color: $color; } }
+SCSS
+
+  end
+
+  def test_empty_content
+    assert_scss_to_scss(<<SCSS)
+@mixin foo {
+  @content; }
+
+@include foo {}
+SCSS
+  end
+
   private
 
   def assert_sass_to_sass(sass, options = {})