haml 3.2.0.alpha.10 → 3.2.0.alpha.13

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

@@ -1,18 +0,0 @@
-module Sass
-  module Tree
-    # A dynamic node representing returning from a function.
-    #
-    # @see Sass::Tree
-    class ReturnNode < Node
-      # The expression to return.
-      # @type [Script::Node]
-      attr_accessor :expr
-
-      # @param expr [Script::Node] The expression to return
-      def initialize(expr)
-        @expr = expr
-        super()
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-module Sass
-  module Tree
-    # A static node that is the root node of the Sass document.
-    class RootNode < Node
-      # The Sass template from which this node was created
-      #
-      # @param template [String]
-      attr_reader :template
-
-      # @param template [String] The Sass template from which this node was created
-      def initialize(template)
-        super()
-        @template = template
-      end
-
-      # Runs the dynamic Sass code *and* computes the CSS for the tree.
-      # @see #to_s
-      def render
-        Visitors::CheckNesting.visit(self)
-        result = Visitors::Perform.visit(self)
-        Visitors::CheckNesting.visit(result) # Check again to validate mixins
-        result, extends = Visitors::Cssize.visit(result)
-        result = result.do_extend(extends) unless extends.empty?
-        result.to_s
-      end
-    end
-  end
-end

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

@@ -1,136 +0,0 @@
-require 'pathname'
-require 'uri'
-
-module Sass::Tree
-  # A static node reprenting a CSS rule.
-  #
-  # @see Sass::Tree
-  class RuleNode < Node
-    # The character used to include the parent selector
-    PARENT = '&'
-
-    # The CSS selector for this rule,
-    # interspersed with {Sass::Script::Node}s
-    # representing `#{}`-interpolation.
-    # Any adjacent strings will be merged together.
-    #
-    # @return [Array<String, Sass::Script::Node>]
-    attr_accessor :rule
-
-    # The CSS selector for this rule,
-    # without any unresolved interpolation
-    # but with parent references still intact.
-    # It's only set once {Tree::Node#perform} has been called.
-    #
-    # @return [Selector::CommaSequence]
-    attr_accessor :parsed_rules
-
-    # The CSS selector for this rule,
-    # without any unresolved interpolation or parent references.
-    # It's only set once {Tree::Visitors::Cssize} has been run.
-    #
-    # @return [Selector::CommaSequence]
-    attr_accessor :resolved_rules
-
-    # How deep this rule is indented
-    # relative to a base-level rule.
-    # This is only greater than 0 in the case that:
-    #
-    # * This node is in a CSS tree
-    # * The style is :nested
-    # * This is a child rule of another rule
-    # * The parent rule has properties, and thus will be rendered
-    #
-    # @return [Fixnum]
-    attr_accessor :tabs
-
-    # Whether or not this rule is the last rule in a nested group.
-    # This is only set in a CSS tree.
-    #
-    # @return [Boolean]
-    attr_accessor :group_end
-
-    # The stack trace.
-    # This is only readable in a CSS tree as it is written during the perform step
-    # and only when the :trace_selectors option is set.
-    #
-    # @return [Array<String>]
-    attr_accessor :stack_trace
-
-    # @param rule [Array<String, Sass::Script::Node>]
-    #   The CSS rule. See \{#rule}
-    def initialize(rule)
-      merged = Sass::Util.merge_adjacent_strings(rule)
-      @rule = Sass::Util.strip_string_array(merged)
-      @tabs = 0
-      try_to_parse_non_interpolated_rules
-      super()
-    end
-
-    # If we've precached the parsed selector, set the line on it, too.
-    def line=(line)
-      @parsed_rules.line = line if @parsed_rules
-      super
-    end
-
-    # If we've precached the parsed selector, set the filename on it, too.
-    def filename=(filename)
-      @parsed_rules.filename = filename if @parsed_rules
-      super
-    end
-
-    # Compares the contents of two rules.
-    #
-    # @param other [Object] The object to compare with
-    # @return [Boolean] Whether or not this node and the other object
-    #   are the same
-    def ==(other)
-      self.class == other.class && rule == other.rule && super
-    end
-
-    # Adds another {RuleNode}'s rules to this one's.
-    #
-    # @param node [RuleNode] The other node
-    def add_rules(node)
-      @rule = Sass::Util.strip_string_array(
-        Sass::Util.merge_adjacent_strings(@rule + ["\n"] + node.rule))
-      try_to_parse_non_interpolated_rules
-    end
-
-    # @return [Boolean] Whether or not this rule is continued on the next line
-    def continued?
-      last = @rule.last
-      last.is_a?(String) && last[-1] == ?,
-    end
-
-    # Extends this Rule's selector with the given `extends`.
-    #
-    # @see Node#do_extend
-    def do_extend(extends)
-      node = dup
-      node.resolved_rules = resolved_rules.do_extend(extends)
-      node
-    end
-
-    # A hash that will be associated with this rule in the CSS document
-    # if the {file:SASS_REFERENCE.md#debug_info-option `:debug_info` option} is enabled.
-    # This data is used by e.g. [the FireSass Firebug extension](https://addons.mozilla.org/en-US/firefox/addon/103988).
-    #
-    # @return [{#to_s => #to_s}]
-    def debug_info
-      {:filename => filename && ("file://" + URI.escape(File.expand_path(filename))),
-       :line => self.line}
-    end
-
-    private
-
-    def try_to_parse_non_interpolated_rules
-      if @rule.all? {|t| t.kind_of?(String)}
-        # We don't use real filename/line info because we don't have it yet.
-        # When we get it, we'll set it on the parsed rules if possible.
-        parser = Sass::SCSS::StaticParser.new(@rule.join.strip, '', 1)
-        @parsed_rules = parser.parse_selector rescue nil
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-module Sass
-  module Tree
-    # A dynamic node representing a variable definition.
-    #
-    # @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_accessor :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] See \{#expr}
-      # @param guarded [Boolean] See \{#guarded}
-      def initialize(name, expr, guarded)
-        @name = name
-        @expr = expr
-        @guarded = guarded
-        super()
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-# 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

@@ -1,133 +0,0 @@
-# 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
-
-  CONTROL_NODES = [Sass::Tree::EachNode, Sass::Tree::ForNode, Sass::Tree::IfNode, Sass::Tree::WhileNode]
-  SCRIPT_NODES = [Sass::Tree::ImportNode, Sass::Tree::MixinNode] + CONTROL_NODES
-  def visit_children(parent)
-    old_parent = @parent
-    @parent = parent unless is_any_of?(parent, SCRIPT_NODES)
-    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
-
-  VALID_EXTEND_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::MixinDefNode]
-  def invalid_extend_parent?(parent, child)
-    unless is_any_of?(parent, VALID_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
-
-  VALID_FUNCTION_CHILDREN = [
-    Sass::Tree::CommentNode,  Sass::Tree::DebugNode, Sass::Tree::ReturnNode,
-    Sass::Tree::VariableNode, Sass::Tree::WarnNode
-  ] + CONTROL_NODES
-  def invalid_function_child?(parent, child)
-    unless is_any_of?(child, VALID_FUNCTION_CHILDREN)
-      "Functions can only contain variable declarations and control directives."
-    end
-  end
-
-  VALID_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, VALID_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
-
-  VALID_PROP_CHILDREN = [Sass::Tree::CommentNode, Sass::Tree::PropNode, Sass::Tree::MixinNode] + CONTROL_NODES
-  def invalid_prop_child?(parent, child)
-    unless is_any_of?(child, VALID_PROP_CHILDREN)
-      "Illegal nesting: Only properties may be nested beneath properties."
-    end
-  end
-
-  VALID_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, VALID_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

@@ -1,260 +0,0 @@
-# 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.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 = node.value.map do |r|
-      next r if r.is_a?(String)
-      "\#{#{r.to_sass(@options)}}"
-    end.join
-
-    content = 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
-
-      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 - value[/^ */].size, 0].max)
-      content = if node.silent
-        value.gsub(/^[\/ ]\*/, '//').gsub(/ *\*\/$/, '')
-      else
-        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