sass 3.1.0.alpha.48 → 3.1.0.alpha.49

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

@@ -0,0 +1,278 @@
+# A visitor for converting a dynamic Sass tree into a static Sass tree.
+class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
+  protected
+
+  def initialize
+    @environment = Sass::Environment.new
+  end
+
+  # If an exception is raised, this add proper metadata to the backtrace.
+  def visit(node)
+    super(node.dup)
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  # Keeps track of the current environment.
+  def visit_children(parent)
+    with_environment Sass::Environment.new(@environment) do
+      parent.children = super.flatten
+      parent.children.each {|c| parent.check_child! c}
+      parent
+    end
+  end
+
+  # Runs a block of code with the current environment replaced with the given one.
+  #
+  # @param env [Sass::Environment] The new environment for the duration of the block.
+  # @yield A block in which the environment is set to `env`.
+  # @return [Object] The return value of the block.
+  def with_environment(env)
+    old_env, @environment = @environment, env
+    yield
+  ensure
+    @environment = old_env
+  end
+
+  # Sets the options on the environment if this is the top-level root.
+  def visit_root(node)
+    @environment.options = node.options if @environment.options.nil? || @environment.options.empty?
+    yield
+  rescue Sass::SyntaxError => e
+    e.sass_template ||= node.template
+    raise e
+  end
+
+  # Removes this node from the tree if it's a silent comment.
+  def visit_comment(node)
+    node.silent ? [] : node
+  end
+
+  # Prints the expression to STDERR.
+  def visit_debug(node)
+    res = node.expr.perform(@environment)
+    res = res.value if res.is_a?(Sass::Script::String)
+    if node.filename
+      $stderr.puts "#{node.filename}:#{node.line} DEBUG: #{res}"
+    else
+      $stderr.puts "Line #{node.line} DEBUG: #{res}"
+    end
+    []
+  end
+
+  # Runs the child nodes once for each value in the list.
+  def visit_each(node)
+    list = node.list.perform(@environment)
+
+    with_environment Sass::Environment.new(@environment) do
+      list.to_a.map do |v|
+        @environment.set_local_var(node.var, v)
+        node.children.map {|c| visit(c)}
+      end.flatten
+    end
+  end
+
+  # 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)
+    node
+  end
+
+  # Runs the child nodes once for each time through the loop, varying the variable each time.
+  def visit_for(node)
+    from = node.from.perform(@environment)
+    to = node.to.perform(@environment)
+    from.assert_int!
+    to.assert_int!
+
+    to = to.coerce(from.numerator_units, from.denominator_units)
+    range = Range.new(from.to_i, to.to_i, node.exclusive)
+
+    with_environment Sass::Environment.new(@environment) do
+      range.map do |i|
+        @environment.set_local_var(node.var,
+          Sass::Script::Number.new(i, from.numerator_units, from.denominator_units))
+        node.children.map {|c| visit(c)}
+      end.flatten
+    end
+  end
+
+  # Runs the child nodes if the conditional expression is true;
+  # otherwise, tries the else nodes.
+  def visit_if(node)
+    if node.expr.nil? || node.expr.perform(@environment).to_bool
+      yield
+      node.children
+    elsif node.else
+      visit(node.else)
+    else
+      []
+    end
+  end
+
+  # Returns a static DirectiveNode if this is importing a CSS file,
+  # or parses and includes the imported Sass file.
+  def visit_import(node)
+    if path = node.css_import?
+      return Sass::Tree::DirectiveNode.new("@import url(#{path})")
+    end
+
+    @environment.push_frame(:filename => node.filename, :line => node.line)
+    root = node.imported_file.to_tree
+    node.children = root.children.map {|c| visit(c)}.flatten
+    node
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.imported_file.options[:filename])
+    e.add_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  ensure
+    @environment.pop_frame
+  end
+
+  # Loads a mixin into the environment.
+  def visit_mixindef(node)
+    @environment.set_mixin(node.name,
+      Sass::Mixin.new(node.name, node.args, @environment, node.children))
+    []
+  end
+
+  # Runs a mixin.
+  def visit_mixin(node)
+    handle_include_loop!(node) if @environment.mixins_in_use.include?(node.name)
+
+    original_env = @environment
+    original_env.push_frame(:filename => node.filename, :line => node.line)
+    original_env.prepare_frame(:mixin => node.name)
+    raise Sass::SyntaxError.new("Undefined mixin '#{node.name}'.") unless mixin = @environment.mixin(node.name)
+
+    passed_args = node.args.dup
+    passed_keywords = node.keywords.dup
+
+    raise Sass::SyntaxError.new(<<END.gsub("\n", "")) if mixin.args.size < passed_args.size
+Mixin #{node.name} takes #{mixin.args.size} argument#{'s' if mixin.args.size != 1}
+ but #{node.args.size} #{node.args.size == 1 ? 'was' : 'were'} passed.
+END
+
+    passed_keywords.each do |name, value|
+      # TODO: Make this fast
+      unless mixin.args.find {|(var, default)| var.underscored_name == name}
+        raise Sass::SyntaxError.new("Mixin #{node.name} doesn't have an argument named $#{name}")
+      end
+    end
+
+    environment = mixin.args.zip(passed_args).
+      inject(Sass::Environment.new(mixin.environment)) do |env, ((var, default), value)|
+      env.set_local_var(var.name,
+        if value
+          value.perform(@environment)
+        elsif kv = passed_keywords[var.underscored_name]
+          kv.perform(env)
+        elsif default
+          val = default.perform(env)
+          if default.context == :equals && val.is_a?(Sass::Script::String)
+            val = Sass::Script::String.new(val.value)
+          end
+          val
+        end)
+      raise Sass::SyntaxError.new("Mixin #{node.name} is missing parameter #{var.inspect}.") unless env.var(var.name)
+      env
+    end
+
+    with_environment(environment) {node.children = mixin.tree.map {|c| visit(c)}.flatten}
+    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)
+      e.add_backtrace(:line => node.line)
+    end
+    raise e
+  ensure
+    original_env.pop_frame if original_env
+  end
+
+  # 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 =
+      if node.value.context == :equals && val.is_a?(Sass::Script::String)
+        val.value
+      else
+        val.to_s
+      end
+    yield
+  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)
+    yield
+  end
+
+  # Loads the new variable value into the environment.
+  def visit_variable(node)
+    return [] if node.guarded && !@environment.var(node.name).nil?
+    val = node.expr.perform(@environment)
+    val = Sass::Script::String.new(val.value) if node.expr.context == :equals && val.is_a?(Sass::Script::String)
+    @environment.set_var(node.name, val)
+    []
+  end
+
+  # Prints the expression to STDERR with a stylesheet trace.
+  def visit_warn(node)
+    @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
+    Sass::Util.sass_warn msg
+    []
+  ensure
+    @environment.pop_frame
+  end
+
+  # Runs the child nodes until the continuation expression becomes false.
+  def visit_while(node)
+    children = []
+    with_environment Sass::Environment.new(@environment) do
+      children += node.children.map {|c| visit(c)} while node.expr.perform(@environment).to_bool
+    end
+    children.flatten
+  end
+
+  private
+
+  def run_interp(text)
+    text.map do |r|
+      next r if r.is_a?(String)
+      val = r.perform(@environment)
+      # Interpolated strings should never render with quotes
+      next val.value if val.is_a?(Sass::Script::String)
+      val.to_s
+    end.join.strip
+  end
+
+  def handle_include_loop!(node)
+    msg = "An @include loop has been found:"
+    mixins = @environment.stack.map {|s| s[:mixin]}.compact
+    if mixins.size == 2 && mixins[0] == mixins[1]
+      raise Sass::SyntaxError.new("#{msg} #{node.name} includes itself")
+    end
+
+    mixins << node.name
+    msg << "\n" << Sass::Util.enum_cons(mixins, 2).map do |m1, m2|
+      "    #{m1} includes #{m2}"
+    end.join("\n")
+    raise Sass::SyntaxError.new(msg)
+  end
+end

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

@@ -0,0 +1,200 @@
+# A visitor for converting a Sass tree into CSS.
+class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
+  protected
+
+  def initialize
+    @tabs = 0
+  end
+
+  def visit(node)
+    super
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  def with_tabs(tabs)
+    old_tabs, @tabs = @tabs, tabs
+    yield
+  ensure
+    @tabs = old_tabs
+  end
+
+  def visit_root(node)
+    result = String.new
+    node.children.each do |child|
+      next if child.invisible?
+      child_str = visit(child)
+      result << child_str + (node.style == :compressed ? '' : "\n")
+    end
+    result.rstrip!
+    return "" if result.empty?
+    result << "\n"
+    unless Sass::Util.ruby1_8? || result.ascii_only?
+      if node.children.first.is_a?(Sass::Tree::CharsetNode)
+        begin
+          encoding = node.children.first.name
+          # Default to big-endian encoding, because we have to decide somehow
+          encoding << 'BE' if encoding =~ /\Autf-(16|32)\Z/i
+          result = result.encode(Encoding.find(encoding))
+        rescue EncodingError
+        end
+      end
+
+      result = "@charset \"#{result.encoding.name}\";#{
+        node.style == :compressed ? '' : "\n"
+      }".encode(result.encoding) + result
+    end
+    result
+  rescue Sass::SyntaxError => e
+    e.sass_template ||= node.template
+    raise e
+  end
+
+  def visit_charset(node)
+    "@charset \"#{node.name}\";"
+  end 
+
+  def visit_comment(node)
+    return if node.invisible?
+    spaces = ('  ' * [@tabs - node.value[/^ */].size, 0].max)
+
+    content = node.value.gsub(/^/, spaces)
+    content.gsub!(/\n +(\* *(?!\/))?/, ' ') if node.style == :compact
+    content
+  end
+
+  def visit_directive(node)
+    return node.value + ";" unless node.has_children
+    return node.value + " {}" if node.children.empty?
+    result = if node.style == :compressed
+               "#{node.value}{"
+             else
+               "#{'  ' * @tabs}#{node.value} {" + (node.style == :compact ? ' ' : "\n")
+             end
+    was_prop = false
+    first = true
+    node.children.each do |child|
+      next if child.invisible?
+      if node.style == :compact
+        if child.is_a?(Sass::Tree::PropNode)
+          with_tabs(first || was_prop ? 0 : @tabs + 1) {result << visit(child) << ' '}
+        else
+          result[-1] = "\n" if was_prop
+          rendered = with_tabs(@tabs + 1) {visit(child).dup}
+          rendered = rendered.lstrip if first
+          result << rendered.rstrip + "\n"
+        end
+        was_prop = child.is_a?(Sass::Tree::PropNode)
+        first = false
+      elsif node.style == :compressed
+        result << (was_prop ? ";" : "") << with_tabs(0) {visit(child)}
+        was_prop = child.is_a?(Sass::Tree::PropNode)
+      else
+        result << with_tabs(@tabs + 1) {visit(child)} + "\n"
+      end
+    end
+    result.rstrip + if node.style == :compressed
+                      "}"
+                    else
+                      (node.style == :expanded ? "\n" : " ") + "}\n"
+                    end
+  end
+
+  def visit_media(node)
+    str = with_tabs(@tabs + node.tabs) {visit_directive(node)}
+    str.gsub!(/\n\Z/, '') unless node.style == :compressed || node.group_end
+    str
+  end
+
+  def visit_prop(node)
+    tab_str = '  ' * (@tabs + node.tabs)
+    if node.style == :compressed
+      "#{tab_str}#{node.resolved_name}:#{node.resolved_value}"
+    else
+      "#{tab_str}#{node.resolved_name}: #{node.resolved_value};"
+    end
+  end
+
+  def visit_rule(node)
+    with_tabs(@tabs + node.tabs) do
+      rule_separator = node.style == :compressed ? ',' : ', '
+      line_separator =
+        case node.style
+          when :nested, :expanded; "\n"
+          when :compressed; ""
+          else; " "
+        end
+      rule_indent = '  ' * @tabs
+      per_rule_indent, total_indent = [:nested, :expanded].include?(node.style) ? [rule_indent, ''] : ['', rule_indent]
+
+      total_rule = total_indent + node.resolved_rules.members.
+        map {|seq| seq.to_a.join.gsub(/([^,])\n/m, node.style == :compressed ? '\1 ' : "\\1\n")}.
+        join(rule_separator).split("\n").map do |line|
+        per_rule_indent + line.strip
+      end.join(line_separator)
+
+      to_return = ''
+      old_spaces = '  ' * @tabs
+      spaces = '  ' * (@tabs + 1)
+      if node.style != :compressed
+        if node.options[:debug_info]
+          to_return << visit(debug_info_rule(node.debug_info, node.options)) << "\n"
+        elsif node.options[:line_comments]
+          to_return << "#{old_spaces}/* line #{node.line}"
+
+          if node.filename
+            relative_filename = if node.options[:css_filename]
+              begin
+                Pathname.new(node.filename).relative_path_from(
+                  Pathname.new(File.dirname(node.options[:css_filename]))).to_s
+              rescue ArgumentError
+                nil
+              end
+            end
+            relative_filename ||= node.filename
+            to_return << ", #{relative_filename}"
+          end
+
+          to_return << " */\n"
+        end
+      end
+
+      if node.style == :compact
+        properties = with_tabs(0) {node.children.map {|a| visit(a)}.join(' ')}
+        to_return << "#{total_rule} { #{properties} }#{"\n" if node.group_end}"
+      elsif node.style == :compressed
+        properties = with_tabs(0) {node.children.map {|a| visit(a)}.join(';')}
+        to_return << "#{total_rule}{#{properties}}"
+      else
+        properties = with_tabs(@tabs + 1) {node.children.map {|a| visit(a)}.join("\n")}
+        end_props = (node.style == :expanded ? "\n" + old_spaces : ' ')
+        to_return << "#{total_rule} {\n#{properties}#{end_props}}#{"\n" if node.group_end}"
+      end
+
+      to_return
+    end
+  end
+
+  private
+
+  def debug_info_rule(debug_info, options)
+    node = Sass::Tree::DirectiveNode.new("@media -sass-debug-info")
+    debug_info.map {|k, v| [k.to_s, v.to_s]}.sort.each do |k, v|
+      rule = Sass::Tree::RuleNode.new([""])
+      rule.resolved_rules = Sass::Selector::CommaSequence.new(
+        [Sass::Selector::Sequence.new(
+            [Sass::Selector::SimpleSequence.new(
+                [Sass::Selector::Element.new(k.to_s.gsub(/[^\w-]/, "\\\\\\0"), nil)])
+            ])
+        ])
+      prop = Sass::Tree::PropNode.new([""], "", :new)
+      prop.resolved_name = "font-family"
+      prop.resolved_value = Sass::SCSS::RX.escape_ident(v.to_s)
+      rule << prop
+      node << rule
+    end
+    node.options = options.merge(:debug_info => false, :line_comments => false, :style => :compressed)
+    node
+  end
+end