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

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

@@ -1,175 +0,0 @@
-# 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]
-  attr_reader :parent
-
-  def initialize
-    @extends = Sass::Util::SubsetMap.new
-  end
-
-  # If an exception is raised, this adds 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 parent node.
-  def visit_children(parent)
-    with_parent parent do
-      parent.children = super.flatten
-      parent
-    end
-  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)
-    old_parent, @parent = @parent, parent
-    yield
-  ensure
-    @parent = old_parent
-  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
-
-    # 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? && parent.nil?
-      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
-
-    return node, @extends
-  rescue Sass::SyntaxError => e
-    e.sass_template ||= node.template
-    raise e
-  end
-
-  # Registers an extension in the `@extends` subset map.
-  def visit_extend(node)
-    node.resolved_selector.members.each do |seq|
-      if seq.members.size > 1
-        raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: can't extend nested selectors")
-      end
-
-      sseq = seq.members.first
-      if !sseq.is_a?(Sass::Selector::SimpleSequence)
-        raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: invalid selector")
-      end
-
-      sel = sseq.members
-      parent.resolved_rules.members.each do |seq|
-        if !seq.members.last.is_a?(Sass::Selector::SimpleSequence)
-          raise Sass::SyntaxError.new("#{seq} can't extend: invalid selector")
-        end
-
-        @extends[sel] = seq
-      end
-    end
-
-    []
-  end
-
-  # Modifies exception backtraces to include the imported file.
-  def visit_import(node)
-    # Don't use #visit_children to avoid adding the import node to the list of parents.
-    node.children.map {|c| visit(c)}.flatten
-  rescue Sass::SyntaxError => e
-    e.modify_backtrace(:filename => node.children.first.filename)
-    e.add_backtrace(:filename => node.filename, :line => node.line)
-    raise e
-  end
-
-  # Bubbles the `@media` directive up through RuleNodes
-  # and merges it with other `@media` directives.
-  def visit_media(node)
-    if parent.is_a?(Sass::Tree::RuleNode)
-      new_rule = parent.dup
-      new_rule.children = node.children
-      node.children = with_parent(node) {Array(visit(new_rule))}
-      # If the last child is actually the end of the group,
-      # the parent's cssize will set it properly
-      node.children.last.group_end = false unless node.children.empty?
-    else
-      yield
-    end
-
-    media = node.children.select {|c| c.is_a?(Sass::Tree::MediaNode)}
-    node.children.reject! {|c| c.is_a?(Sass::Tree::MediaNode)}
-    media.each {|n| n.query = "#{node.query} and #{n.query}"}
-    (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.
-    node.children.map {|c| visit(c)}.flatten
-  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
-
-  # Resolves parent references and nested selectors,
-  # and updates the indentation of the rule node based on the nesting level.
-  def visit_rule(node)
-    parent_resolved_rules = parent.is_a?(Sass::Tree::RuleNode) ? parent.resolved_rules : nil
-    # It's possible for resolved_rules to be set if we've duplicated this node during @media bubbling
-    node.resolved_rules ||= node.parsed_rules.resolve_parent_refs(parent_resolved_rules)
-
-    yield
-
-    rules = node.children.select {|c| c.is_a?(Sass::Tree::RuleNode) || c.is_a?(Sass::Tree::MediaNode)}
-    props = node.children.reject {|c| c.is_a?(Sass::Tree::RuleNode) || c.is_a?(Sass::Tree::MediaNode) || c.invisible?}
-
-    unless props.empty?
-      node.children = props
-      rules.each {|r| r.tabs += 1} if node.style == :nested
-      rules.unshift(node)
-    end
-
-    rules.last.group_end = true unless parent.is_a?(Sass::Tree::RuleNode) || rules.empty?
-
-    rules
-  end
-end

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

@@ -1,87 +0,0 @@
-# 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_mixindef(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/vendor/sass/lib/sass/tree/visitors/perform.rb

@@ -1,332 +0,0 @@
-# A visitor for converting a dynamic Sass tree into a static Sass tree.
-class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
-  # @param root [Tree::Node] The root node of the tree to visit.
-  # @param environment [Sass::Environment] The lexical environment.
-  # @return [Tree::Node] The resulting tree of static nodes.
-  def self.visit(root, environment = Sass::Environment.new)
-    new(environment).send(:visit, root)
-  end
-
-  protected
-
-  def initialize(env)
-    @environment = env
-  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
-    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)
-    return [] if node.invisible?
-    check_for_loud_silent_comment node
-    check_for_comment_interp node
-    node.resolved_value = run_interp_no_strip(node.value)
-    node.resolved_value.gsub!(/\\([\\#])/, '\1')
-    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.filename, node.line)
-    node.resolved_selector = parser.parse_selector
-    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
-
-  # 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))
-    []
-  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
-    Sass::Tree::Visitors::CheckNesting.visit(root)
-    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::Callable.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(@environment)
-        elsif default
-          default.perform(env)
-        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 = val.to_s
-    yield
-  end
-
-  # Returns the value of the expression.
-  def visit_return(node)
-    throw :_sass_return, node.expr.perform(@environment)
-  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.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
-
-  # 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)
-    @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         "
-    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
-    @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
-
-  def visit_directive(node)
-    if node.value['#{']
-      node.value = run_interp(Sass::Engine.parse_interp(node.value, node.line, 0, node.options))
-    end
-    yield
-    node
-  end
-
-  private
-
-  def run_interp_no_strip(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
-  end
-
-  def run_interp(text)
-    run_interp_no_strip(text).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
-
-  def check_for_loud_silent_comment(node)
-    return unless node.loud && node.silent
-    Sass::Util.sass_warn <<MESSAGE
-WARNING:
-On line #{node.line}#{" of '#{node.filename}'" if node.filename}
-`//` comments will no longer be allowed to use the `!` flag in Sass 3.2.
-Please change to `/*` comments.
-MESSAGE
-  end
-
-  def check_for_comment_interp(node)
-    return if node.loud
-    node.value.each do |e|
-      next unless e.is_a?(String)
-      e.scan(/(\\*)#\{/) do |esc|
-        Sass::Util.sass_warn <<MESSAGE if esc.first.size.even?
-WARNING:
-On line #{node.line}#{" of '#{node.filename}'" if node.filename}
-Comments will evaluate the contents of interpolations (\#{ ... }) in Sass 3.2.
-Please escape the interpolation by adding a backslash before the `#`.
-MESSAGE
-        return
-      end
-    end
-  end
-end