brakeman 4.4.0 → 4.5.0

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/tree/visitors/convert.rb

@@ -1,351 +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
-    # 2 spaces by default
-    @tab_chars = @options[:indent] || "  "
-    @is_else = false
-  end
-
-  def visit_children(parent)
-    @tabs += 1
-    return @format == :sass ? "\n" : " {}\n" if parent.children.empty?
-
-    res = visit_rule_level(parent.children)
-
-    if @format == :sass
-      "\n" + res.rstrip + "\n"
-    else
-      " {\n" + res.rstrip + "\n#{@tab_chars * (@tabs - 1)}}\n"
-    end
-  ensure
-    @tabs -= 1
-  end
-
-  # Ensures proper spacing between top-level nodes.
-  def visit_root(node)
-    visit_rule_level(node.children)
-  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(%r{\*/$}, '').rstrip
-      if content =~ /\A[ \t]/
-        # Re-indent SCSS comments like this:
-        #     /* foo
-        #   bar
-        #       baz */
-        content.gsub!(/^/, '   ')
-        content.sub!(%r{\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!(%r{\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(%r{^[/ ]\*}, '//').gsub(%r{ *\*/$}, '')
-                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
-  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}" +
-      "#{' !optional' if node.optional?}#{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(", ")
-    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 << " supports(#{node.supports_condition.to_src(@options)})" if node.supports_condition
-    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).lstrip}#{visit_children(rule)}"
-    else
-      "#{tab_str}@at-root#{yield}"
-    end
-  end
-
-  def visit_keyframerule(node)
-    "#{tab_str}#{node.resolved_value}#{yield}"
-  end
-
-  private
-
-  # Visit rule-level nodes and return their conversion with appropriate
-  # whitespace added.
-  def visit_rule_level(nodes)
-    Sass::Util.enum_cons(nodes + [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) ||
-            (child.is_a?(Sass::Tree::PropNode) && nxt.is_a?(Sass::Tree::PropNode)) ||
-            (child.is_a?(Sass::Tree::MixinNode) && nxt.is_a?(Sass::Tree::MixinNode) &&
-              child.line + 1 == nxt.line)
-          ""
-        else
-          "\n"
-        end
-    end.join.rstrip + "\n"
-  end
-
-  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.tr('_', '-')
-    else
-      s
-    end
-  end
-end

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/tree/visitors/cssize.rb

@@ -1,373 +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]
-  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
-    if parent.is_a?(Sass::Tree::RuleNode)
-      # @keyframes shouldn't include the rule nodes, so we manually create a
-      # bubble that doesn't have the parent's contents for them.
-      return node.normalized_name == '@keyframes' ? Bubble.new(node) : bubble(node)
-    end
-
-    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