oreorenasass 3.4.0

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

@@ -0,0 +1,334 @@
+# A visitor for converting a Sass tree into a source string.
+class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
+  # Runs the visitor on a tree.
+  #
+  # @param root [Tree::Node] The root node of the Sass tree.
+  # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
+  # @param format [Symbol] `:sass` or `:scss`.
+  # @return [String] The Sass or SCSS source for the tree.
+  def self.visit(root, options, format)
+    new(options, format).send(:visit, root)
+  end
+
+  protected
+
+  def initialize(options, format)
+    @options = options
+    @format = format
+    @tabs = 0
+    # 2 spaces by default
+    @tab_chars = @options[:indent] || "  "
+  end
+
+  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
+  ensure
+    @tabs -= 1
+  end
+
+  # Ensures proper spacing between top-level nodes.
+  def visit_root(node)
+    Sass::Util.enum_cons(node.children + [nil], 2).map do |child, nxt|
+      visit(child) +
+        if nxt &&
+            (child.is_a?(Sass::Tree::CommentNode) &&
+              child.line + child.lines + 1 == nxt.line) ||
+            (child.is_a?(Sass::Tree::ImportNode) && nxt.is_a?(Sass::Tree::ImportNode) &&
+              child.line + 1 == nxt.line) ||
+            (child.is_a?(Sass::Tree::VariableNode) && nxt.is_a?(Sass::Tree::VariableNode) &&
+              child.line + 1 == nxt.line)
+          ""
+        else
+          "\n"
+        end
+    end.join.rstrip + "\n"
+  end
+
+  def visit_charset(node)
+    "#{tab_str}@charset \"#{node.name}\"#{semi}\n"
+  end
+
+  def visit_comment(node)
+    value = interp_to_src(node.value)
+    if @format == :sass
+      content = value.gsub(/\*\/$/, '').rstrip
+      if content =~ /\A[ \t]/
+        # Re-indent SCSS comments like this:
+        #     /* foo
+        #   bar
+        #       baz */
+        content.gsub!(/^/, '   ')
+        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)
+        else
+          content.gsub!(/\n#{' ' * spaces}/, sep)
+        end
+      end
+
+      content.gsub!(/\A\/\*/, '//') if node.type == :silent
+      content.gsub!(/^/, tab_str)
+      content = 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"
+    end
+    content
+  end
+
+  def visit_debug(node)
+    "#{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')
+    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}"
+  end
+
+  def visit_extend(node)
+    "#{tab_str}@extend #{selector_to_src(node.selector).lstrip}#{semi}" +
+      "#{" !optional" if node.optional?}\n"
+  end
+
+  def visit_for(node)
+    "#{tab_str}@for $#{dasherize(node.var)} from #{node.from.to_sass(@options)} " +
+      "#{node.exclusive ? "to" : "through"} #{node.to.to_sass(@options)}#{yield}"
+  end
+
+  def visit_function(node)
+    args = node.args.map do |v, d|
+      d ? "#{v.to_sass(@options)}: #{d.to_sass(@options)}" : v.to_sass(@options)
+    end.join(", ")
+    if node.splat
+      args << ", " unless node.args.empty?
+      args << node.splat.to_sass(@options) << "..."
+    end
+
+    "#{tab_str}@function #{dasherize(node.name)}(#{args})#{yield}"
+  end
+
+  def visit_if(node)
+    name =
+      if !@is_else
+        "if"
+      elsif node.expr
+        "else if"
+      else
+        "else"
+      end
+    @is_else = false
+    str = "#{tab_str}@#{name}"
+    str << " #{node.expr.to_sass(@options)}" if node.expr
+    str << yield
+    @is_else = true
+    str << visit(node.else) if node.else
+    str
+  ensure
+    @is_else = false
+  end
+
+  def visit_import(node)
+    quote = @format == :scss ? '"' : ''
+    "#{tab_str}@import #{quote}#{node.imported_filename}#{quote}#{semi}\n"
+  end
+
+  def visit_media(node)
+    "#{tab_str}@media #{query_interp_to_src(node.query)}#{yield}"
+  end
+
+  def visit_supports(node)
+    "#{tab_str}@#{node.name} #{node.condition.to_src(@options)}#{yield}"
+  end
+
+  def visit_cssimport(node)
+    if node.uri.is_a?(Sass::Script::Tree::Node)
+      str = "#{tab_str}@import #{node.uri.to_sass(@options)}"
+    else
+      str = "#{tab_str}@import #{node.uri}"
+    end
+    str << " #{interp_to_src(node.query)}" unless node.query.empty?
+    "#{str}#{semi}\n"
+  end
+
+  def visit_mixindef(node)
+    args =
+      if node.args.empty? && node.splat.nil?
+        ""
+      else
+        str = '('
+        str << node.args.map do |v, d|
+          if d
+            "#{v.to_sass(@options)}: #{d.to_sass(@options)}"
+          else
+            v.to_sass(@options)
+          end
+        end.join(", ")
+
+        if node.splat
+          str << ", " unless node.args.empty?
+          str << node.splat.to_sass(@options) << '...'
+        end
+
+        str << ')'
+      end
+
+    "#{tab_str}#{@format == :sass ? '=' : '@mixin '}#{dasherize(node.name)}#{args}#{yield}"
+  end
+
+  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
+    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]}"}
+
+      if node.splat
+        splat = "#{arg_to_sass[node.splat]}..."
+        kwarg_splat = "#{arg_to_sass[node.kwarg_splat]}..." if node.kwarg_splat
+      end
+
+      arglist = "(#{[args, splat, keywords, kwarg_splat].flatten.compact.join(', ')})"
+    end
+    "#{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)
+    res = tab_str + node.declaration(@options, @format)
+    return res + semi + "\n" if node.children.empty?
+    res + yield.rstrip + semi + "\n"
+  end
+
+  def visit_return(node)
+    "#{tab_str}@return #{node.expr.to_sass(@options)}#{semi}\n"
+  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 = "\\" + name if name[0] == ?:
+      name.gsub(/^/, tab_str) + yield
+    elsif @format == :scss
+      name = selector_to_scss(rule)
+      res = name + yield
+      if node.children.last.is_a?(Sass::Tree::CommentNode) && node.children.last.type == :silent
+        res.slice!(-3..-1)
+        res << "\n" << tab_str << "}\n"
+      end
+      res
+    end
+  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"
+  end
+
+  def visit_warn(node)
+    "#{tab_str}@warn #{node.expr.to_sass(@options)}#{semi}\n"
+  end
+
+  def visit_while(node)
+    "#{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
+  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)
+  end
+
+  def selector_to_src(sel)
+    @format == :sass ? selector_to_sass(sel) : selector_to_scss(sel)
+  end
+
+  def selector_to_sass(sel)
+    sel.map do |r|
+      if r.is_a?(String)
+        r.gsub(/(,)?([ \t]*)\n\s*/) {$1 ? "#{$1}#{$2}\n" : " "}
+      else
+        r.to_sass(@options)
+      end
+    end.join
+  end
+
+  def selector_to_scss(sel)
+    interp_to_src(sel).gsub(/^[ \t]*/, tab_str).gsub(/[ \t]*$/, '')
+  end
+
+  def semi
+    @format == :sass ? "" : ";"
+  end
+
+  def tab_str
+    @tab_chars * @tabs
+  end
+
+  def dasherize(s)
+    if @options[:dasherize]
+      s.gsub('_', '-')
+    else
+      s
+    end
+  end
+end

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

@@ -0,0 +1,369 @@
+# A visitor for converting a static Sass tree into a static CSS tree.
+class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
+  # @param root [Tree::Node] The root node of the tree to visit.
+  # @return [(Tree::Node, Sass::Util::SubsetMap)] The resulting tree of static nodes
+  #   *and* the extensions defined for this tree
+  def self.visit(root); super; end
+
+  protected
+
+  # Returns the immediate parent of the current node.
+  # @return [Tree::Node]
+  def parent
+    @parents.last
+  end
+
+  def initialize
+    @parents = []
+    @extends = Sass::Util::SubsetMap.new
+  end
+
+  # If an exception is raised, this adds proper metadata to the backtrace.
+  def visit(node)
+    super(node)
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  # Keeps track of the current parent node.
+  def visit_children(parent)
+    with_parent parent do
+      parent.children = visit_children_without_parent(parent)
+      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
+
+  # Runs a block of code with the current parent node
+  # replaced with the given node.
+  #
+  # @param parent [Tree::Node] The new parent for the duration of the block.
+  # @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
+    yield
+  ensure
+    @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.
+  #
+  # @return [(Tree::Node, Sass::Util::SubsetMap)] The resulting tree of static nodes
+  #   *and* the extensions defined for this tree
+  def visit_root(node)
+    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
+      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
+
+      if import_limit
+        node.children = node.children[0...import_limit] + imports_to_move +
+          node.children[import_limit..-1]
+      end
+    end
+
+    return node, @extends
+  rescue Sass::SyntaxError => e
+    e.sass_template ||= node.template
+    raise e
+  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
+  # the extended selector is a comma sequence.
+  #
+  # @attr extender [Sass::Selector::Sequence]
+  #   The selector of the CSS rule containing the `@extend`.
+  # @attr target [Array<Sass::Selector::Simple>] The selector being `@extend`ed.
+  # @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)
+
+  # 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)})
+    []
+  end
+
+  # Modifies exception backtraces to include the imported file.
+  def visit_import(node)
+    visit_children_without_parent(node)
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.children.first.filename)
+    e.add_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  # Asserts that all the traced children are valid in their new location.
+  def visit_trace(node)
+    visit_children_without_parent(node)
+  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)
+    raise e
+  end
+
+  # Converts nested properties into flat properties
+  # and updates the indentation of the prop node based on the nesting level.
+  def visit_prop(node)
+    if parent.is_a?(Sass::Tree::PropNode)
+      node.resolved_name = "#{parent.resolved_name}-#{node.resolved_name}"
+      node.tabs = parent.tabs + (parent.resolved_value.empty? ? 0 : 1) if node.style == :nested
+    end
+
+    yield
+
+    result = node.children.dup
+    if !node.resolved_value.empty? || node.children.empty?
+      node.send(:check!)
+      result.unshift(node)
+    end
+
+    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| bubblable?(c)}
+    props = node.children.reject {|c| bubblable?(c) || c.invisible?}
+
+    unless props.empty?
+      node.children = props
+      rules.each {|r| r.tabs += 1} if node.style == :nested
+      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
+
+  # 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)
+  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)
+    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
+  end
+end