haml 3.1.0 → 3.1.1

data/vendor/sass/lib/sass/tree/variable_node.rb

@@ -4,36 +4,27 @@ module Sass
     #
     # @see Sass::Tree
     class VariableNode < Node
+      # The name of the variable.
+      # @return [String]
+      attr_reader :name
+
+      # The parse tree for the variable value.
+      # @return [Script::Node]
+      attr_reader :expr
+
+      # Whether this is a guarded variable assignment (`!default`).
+      # @return [Boolean]
+      attr_reader :guarded
+
       # @param name [String] The name of the variable
-      # @param expr [Script::Node] The parse tree for the initial variable value
-      # @param guarded [Boolean] Whether this is a guarded variable assignment (`||=`)
+      # @param expr [Script::Node] See \{#expr}
+      # @param guarded [Boolean] See \{#guarded}
       def initialize(name, expr, guarded)
         @name = name
         @expr = expr
         @guarded = guarded
         super()
       end
-
-      protected
-
-      # @see Node#to_src
-      def to_src(tabs, opts, fmt)
-        "#{'  ' * tabs}$#{dasherize(@name, opts)}: #{@expr.to_sass(opts)}#{' !default' if @guarded}#{semi fmt}\n"
-      end
-
-      # Loads the new variable value into the environment.
-      #
-      # @param environment [Sass::Environment] The lexical environment containing
-      #   variable and mixin values
-      def _perform(environment)
-        return [] if @guarded && !environment.var(@name).nil?
-        val = @expr.perform(environment)
-        if @expr.context == :equals && val.is_a?(Sass::Script::String)
-          val = Sass::Script::String.new(val.value)
-        end
-        environment.set_var(@name, val)
-        []
-      end
     end
   end
 end

data/vendor/sass/lib/sass/tree/visitors/base.rb

@@ -0,0 +1,75 @@
+# Visitors are used to traverse the Sass parse tree.
+# Visitors should extend {Visitors::Base},
+# which provides a small amount of scaffolding for traversal.
+module Sass::Tree::Visitors
+  # The abstract base class for Sass visitors.
+  # Visitors should extend this class,
+  # then implement `visit_*` methods for each node they care about
+  # (e.g. `visit_rule` for {RuleNode} or `visit_for` for {ForNode}).
+  # These methods take the node in question as argument.
+  # They may `yield` to visit the child nodes of the current node.
+  #
+  # *Note*: due to the unusual nature of {Sass::Tree::IfNode},
+  # special care must be taken to ensure that it is properly handled.
+  # In particular, there is no built-in scaffolding
+  # for dealing with the return value of `@else` nodes.
+  #
+  # @abstract
+  class Base
+    # Runs the visitor on a tree.
+    #
+    # @param root [Tree::Node] The root node of the Sass tree.
+    # @return [Object] The return value of \{#visit} for the root node.
+    def self.visit(root)
+      new.send(:visit, root)
+    end
+
+    protected
+
+    # Runs the visitor on the given node.
+    # This can be overridden by subclasses that need to do something for each node.
+    #
+    # @param node [Tree::Node] The node to visit.
+    # @return [Object] The return value of the `visit_*` method for this node.
+    def visit(node)
+      method = "visit_#{node_name node}"
+      if self.respond_to?(method)
+        self.send(method, node) {visit_children(node)}
+      else
+        visit_children(node)
+      end
+    end
+
+    # Visit the child nodes for a given node.
+    # This can be overridden by subclasses that need to do something
+    # with the child nodes' return values.
+    #
+    # This method is run when `visit_*` methods `yield`,
+    # and its return value is returned from the `yield`.
+    #
+    # @param parent [Tree::Node] The parent node of the children to visit.
+    # @return [Array<Object>] The return values of the `visit_*` methods for the children.
+    def visit_children(parent)
+      parent.children.map {|c| visit(c)}
+    end
+
+    NODE_NAME_RE = /.*::(.*?)Node$/
+
+    # Returns the name of a node as used in the `visit_*` method.
+    #
+    # @param [Tree::Node] node The node.
+    # @return [String] The name.
+    def node_name(node)
+      @@node_names ||= {}
+      @@node_names[node.class.name] ||= node.class.name.gsub(NODE_NAME_RE, '\\1').downcase
+    end
+
+    # `yield`s, then runs the visitor on the `@else` clause if the node has one.
+    # This exists to ensure that the contents of the `@else` clause get visited.
+    def visit_if(node)
+      yield
+      visit(node.else) if node.else
+      node
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# A visitor for checking that all nodes are properly nested.
+class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
+  protected
+
+  def visit(node)
+    if error = (@parent && (
+          try_send("invalid_#{node_name @parent}_child?", @parent, node) ||
+          try_send("invalid_#{node_name node}_parent?", @parent, node))) ||
+        (@real_parent && (
+          try_send("invalid_#{node_name @real_parent}_real_child?", @real_parent, node) ||
+          try_send("invalid_#{node_name node}_real_parent?", @real_parent, node)))
+      raise Sass::SyntaxError.new(error)
+    end
+    super
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  PARENT_CLASSES = [ Sass::Tree::EachNode,   Sass::Tree::ForNode,   Sass::Tree::IfNode,
+                     Sass::Tree::ImportNode, Sass::Tree::MixinNode, Sass::Tree::WhileNode]
+  def visit_children(parent)
+    old_parent = @parent
+    @parent = parent unless is_any_of?(parent, PARENT_CLASSES)
+    old_real_parent, @real_parent = @real_parent, parent
+    super
+  ensure
+    @parent = old_parent
+    @real_parent = old_real_parent
+  end
+
+  def visit_root(node)
+    yield
+  rescue Sass::SyntaxError => e
+    e.sass_template ||= node.template
+    raise e
+  end
+
+  def visit_import(node)
+    yield
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.children.first.filename)
+    e.add_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  def invalid_charset_parent?(parent, child)
+    "@charset may only be used at the root of a document." unless parent.is_a?(Sass::Tree::RootNode)
+  end
+
+  INVALID_EXTEND_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::MixinDefNode]
+  def invalid_extend_parent?(parent, child)
+    unless is_any_of?(parent, INVALID_EXTEND_PARENTS)
+      "Extend directives may only be used within rules."
+    end
+  end
+
+  def invalid_function_parent?(parent, child)
+    "Functions may only be defined at the root of a document." unless parent.is_a?(Sass::Tree::RootNode)
+  end
+
+  INVALID_FUNCTION_CHILDREN = [
+    Sass::Tree::CommentNode,  Sass::Tree::DebugNode, Sass::Tree::EachNode,
+    Sass::Tree::ForNode,      Sass::Tree::IfNode,    Sass::Tree::ReturnNode,
+    Sass::Tree::VariableNode, Sass::Tree::WarnNode,  Sass::Tree::WhileNode
+  ]
+  def invalid_function_child?(parent, child)
+    unless is_any_of?(child, INVALID_FUNCTION_CHILDREN)
+      "Functions can only contain variable declarations and control directives."
+    end
+  end
+
+  INVALID_IMPORT_PARENTS = [
+    Sass::Tree::IfNode,   Sass::Tree::ForNode, Sass::Tree::WhileNode,
+    Sass::Tree::EachNode, Sass::Tree::MixinDefNode
+  ]
+  def invalid_import_parent?(parent, child)
+    if is_any_of?(@real_parent, INVALID_IMPORT_PARENTS)
+      return "Import directives may not be used within control directives or mixins."
+    end
+    return if parent.is_a?(Sass::Tree::RootNode)
+    return "CSS import directives may only be used at the root of a document." if child.css_import?
+    # If this is a nested @import, we need to make sure it doesn't have anything
+    # that's legal at top-level but not in the current context (e.g. mixin defs).
+    child.imported_file.to_tree.children.each {|c| visit(c)}
+    nil
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => child.imported_file.options[:filename])
+    e.add_backtrace(:filename => child.filename, :line => child.line)
+    raise e
+  end
+
+  def invalid_import_real_parent?(parent, child)
+    
+  end
+
+  def invalid_mixindef_parent?(parent, child)
+    "Mixins may only be defined at the root of a document." unless parent.is_a?(Sass::Tree::RootNode)
+  end
+
+  INVALID_PROP_CHILDREN = [Sass::Tree::CommentNode, Sass::Tree::PropNode]
+  def invalid_prop_child?(parent, child)
+    unless is_any_of?(child, INVALID_PROP_CHILDREN)
+      "Illegal nesting: Only properties may be nested beneath properties."
+    end
+  end
+
+  INVALID_PROP_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::PropNode,
+                          Sass::Tree::MixinDefNode, Sass::Tree::DirectiveNode]
+  def invalid_prop_parent?(parent, child)
+    unless is_any_of?(parent, INVALID_PROP_PARENTS)
+      "Properties are only allowed within rules, directives, or other properties." + child.pseudo_class_selector_message
+    end
+  end
+
+  def invalid_return_parent?(parent, child)
+    "@return may only be used within a function." unless parent.is_a?(Sass::Tree::FunctionNode)
+  end
+
+  private
+
+  def is_any_of?(val, classes)
+    for c in classes
+      return true if val.is_a?(c)
+    end
+    return false
+  end
+
+  def try_send(method, *args, &block)
+    return unless respond_to?(method)
+    send(method, *args, &block)
+  end
+end
+

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

@@ -0,0 +1,255 @@
+# 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
+  end
+
+  def visit_children(parent)
+    @tabs += 1
+    return @format == :sass ? "\n" : " {}\n" if parent.children.empty?
+    (@format == :sass ? "\n" : " {\n") + super.join.rstrip + (@format == :sass ? "\n" : " }\n")
+  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.value.count("\n") + 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)
+    content = if @format == :sass
+      content = node.value.gsub(/\*\/$/, '').rstrip
+      if content =~ /\A[ \t]/
+        # Re-indent SCSS comments like this:
+        #     /* foo
+        #   bar
+        #       baz */
+        content.gsub!(/^/, '   ')
+        content.sub!(/\A([ \t]*)\/\*/, '/*\1')
+      end
+
+      content =
+        unless content.include?("\n")
+          content
+        else
+          content.gsub!(/\n( \*|\/\/)/, "\n  ")
+          spaces = content.scan(/\n( *)/).map {|s| s.first.size}.min
+          sep = node.silent ? "\n//" : "\n *"
+          if spaces >= 2
+            content.gsub(/\n  /, sep)
+          else
+            content.gsub(/\n#{' ' * spaces}/, sep)
+          end
+        end
+
+      content.gsub!(/\A\/\*/, '//') if node.silent
+      content.gsub!(/^/, tab_str)
+      content.rstrip + "\n"
+    else
+      spaces = ('  ' * [@tabs - node.value[/^ */].size, 0].max)
+      content = if node.silent
+        node.value.gsub(/^[\/ ]\*/, '//').gsub(/ *\*\/$/, '')
+      else
+        node.value
+      end.gsub(/^/, spaces) + "\n"
+      content
+    end
+    if node.loud
+      if node.silent
+        content.gsub!(%r{^\s*(//!?)}, '//!')
+      else
+        content.sub!(%r{^\s*(/\*)}, '/*!')
+      end
+    end
+    content
+  end
+
+  def visit_debug(node)
+    "#{tab_str}@debug #{node.expr.to_sass(@options)}#{semi}\n"
+  end
+
+  def visit_directive(node)
+    res = "#{tab_str}#{node.value}"
+    return res + "#{semi}\n" unless node.has_children
+    res + yield + "\n"
+  end
+
+  def visit_each(node)
+    "#{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}\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(", ")
+
+    "#{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
+    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 #{node.query}#{yield}"
+  end
+
+  def visit_mixindef(node)
+    args =
+      if node.args.empty?
+        ""
+      else
+        '(' + node.args.map do |v, d|
+          if d
+            "#{v.to_sass(@options)}: #{d.to_sass(@options)}"
+          else
+            v.to_sass(@options)
+          end
+        end.join(", ") + ')'
+      end
+          
+    "#{tab_str}#{@format == :sass ? '=' : '@mixin '}#{dasherize(node.name)}#{args}#{yield}"
+  end
+
+  def visit_mixin(node)
+    unless node.args.empty? && node.keywords.empty?
+      args = node.args.map {|a| a.to_sass(@options)}.join(", ")
+      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"
+  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)
+    if @format == :sass
+      name = selector_to_sass(node.rule)
+      name = "\\" + name if name[0] == ?:
+      name.gsub(/^/, tab_str) + yield
+    elsif @format == :scss
+      name = selector_to_scss(node.rule)
+      res = name + yield
+      if node.children.last.is_a?(Sass::Tree::CommentNode) && node.children.last.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)}#{' !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
+
+  private
+
+  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 + "\n" : " "}
+      else
+        "\#{#{r.to_sass(@options)}}"
+      end
+    end.join
+  end
+
+  def selector_to_scss(sel)
+    sel.map {|r| r.is_a?(String) ? r : "\#{#{r.to_sass(@options)}}"}.
+      join.gsub(/^[ \t]*/, tab_str)
+  end
+
+  def semi
+    @format == :sass ? "" : ";"
+  end
+
+  def tab_str
+    '  ' * @tabs
+  end
+
+  def dasherize(s)
+    if @options[:dasherize]
+      s.gsub('_', '-')
+    else
+      s
+    end
+  end
+end