red 3.0.0

data/History.txt

@@ -0,0 +1,4 @@
+== 3.0.0 2008-08-06
+
+* 1 major enhancement:
+  * Initial Rubyforge release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Jesse Sielaff
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,41 @@
+History.txt
+License.txt
+Manifest.txt
+PostInstall.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+lib/red.rb
+lib/red/assignment_nodes.rb
+lib/red/call_nodes.rb
+lib/red/conditional_nodes.rb
+lib/red/conjunction_nodes.rb
+lib/red/constant_nodes.rb
+lib/red/control_nodes.rb
+lib/red/data_nodes.rb
+lib/red/definition_nodes.rb
+lib/red/errors.rb
+lib/red/illegal_nodes.rb
+lib/red/literal_nodes.rb
+lib/red/variable_nodes.rb
+lib/red/version.rb
+lib/red/wrap_nodes.rb
+script/console
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+spec/red_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/red.rake
+tasks/rspec.rake
+tasks/website.rake
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.html.erb

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on red, see http://red.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.txt

@@ -0,0 +1,28 @@
+= Turn your JavaScript Red.
+
+Red is a Ruby-to-JavaScript transliterator using ParseTree.
+
+=== License:
+
+(The MIT License)
+
+Copyright (c) 2008 FIXME full name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/config/hoe.rb

@@ -0,0 +1,74 @@
+require 'red/version'
+
+AUTHOR = 'Jesse Sielaff'
+EMAIL = "jesse.sielaff@gmail.com"
+DESCRIPTION = "A Ruby-to-JavaScript transliterator using ParseTree."
+GEM_NAME = 'red'
+RUBYFORGE_PROJECT = 'red-js'
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+EXTRA_DEPENDENCIES = [
+  ['parse_tree', '>= 2.2.0'],
+  ['rake', '>= 0.8.1']
+]
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil
+# UNCOMMENT IF REQUIRED:
+# REV = YAML.load(`svn info`)['Revision']
+VERS = Red::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'red documentation',
+    "--opname", "index.html",
+    "--line-numbers",
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
+    @extra_deps
+  end
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description = DESCRIPTION
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = EXTRA_DEPENDENCIES
+
+    #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  end
+
+CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+$hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+$hoe.rsync_args = '-av --delete --ignore-errors'
+$hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""

data/config/requirements.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))

data/lib/red/assignment_nodes.rb

@@ -0,0 +1,126 @@
+module Red
+  class AssignmentNode # :nodoc:
+    def initialize(variable_name, expression)
+      raise(BuildError::NoMultilineAssignment, "Multiline assignment (e.g. foo = begin; line1; line2; end) is not supported") if expression.first == :block
+      @variable_name, @expression = [variable_name, expression].build_nodes
+    end
+    
+    def compile_internals(options = {})
+      return [@variable_name, @expression].compile_nodes(:as_argument => true)
+    end
+    
+    class ClassVariableNode < AssignmentNode  # :nodoc:
+      def compile_node(options = {})
+        if options[:as_prototype]
+          receiver = @variable_name.compile_node
+          "%s: %s"
+        else
+          receiver = "%s.%s" % [@@red_class, @variable_name.compile_node]
+          "%s = %s"
+        end % [receiver, @expression.compile_node(:as_argument => true)]
+      end
+    end
+    
+    class GlobalVariableNode < AssignmentNode  # :nodoc:
+      def compile_node(options = {})
+        return "%s = %s" % self.compile_internals
+      end
+    end
+    
+    class InstanceVariableNode < AssignmentNode # :nodoc:
+      def compile_node(options = {})
+        return "this.%s = %s" % self.compile_internals
+      end
+    end
+    
+    class LocalVariableNode < AssignmentNode # :nodoc:
+      def compile_node(options = {})
+        return (@variable_name.is_a?(LiteralNode::NamespaceNode) ? "%s = %s" : "var %s = %s") % self.compile_internals
+      end
+    end
+    
+    class AttributeNode # :nodoc:
+      def initialize(variable_name, slot_equals, arguments)
+        @variable_name, @expression = [variable_name, arguments.last].build_nodes
+        @slot = (slot_equals == :[]= ? arguments[1] : slot_equals.to_s.gsub(/=/,'').to_sym).build_node
+      end
+      
+      def compile_node(options = {})
+        return "%s = %s" % compile_internals
+      end
+      
+      def compile_internals(options = {})
+        variable_name, slot, expression = [@variable_name, @slot, @expression].compile_nodes(:quotes => '', :as_argument => true)
+        receiver = self.compile_receiver(variable_name, slot)
+        return [receiver, expression]
+      end
+      
+      def compile_receiver(variable_name, slot)
+        return ([:symbol, :string].include?((@slot.data_type rescue :node)) ? "%s.%s" : "%s[%s]") % [variable_name, slot]
+      end
+    end
+    
+    class OperatorNode # :nodoc:
+      def compile_node(options = {})
+        return "%s%s = %s %s %s" % self.compile_internals
+      end
+      
+      def compile_internals(options = {})
+        receiver, operation = [@receiver, @operation].compile_nodes
+        expression = @expression.compile_node(:as_argument => true)
+        slot       = @slot.compile_node(:quotes => '')
+        original   = self.compile_receiver(receiver, slot)
+        var        = (self.var? rescue nil)
+        return [var, original, original, operation, expression]
+      end
+      
+      class BracketNode < OperatorNode # :nodoc:
+        def initialize(receiver, bracket_contents, operation, expression)
+          @receiver, @slot, @operation, @expression = [receiver, bracket_contents.last, operation, expression].build_nodes
+        end
+        
+        def compile_receiver(receiver, slot)
+          return ([:symbol, :string].include?((@slot.data_type rescue :node)) ? "%s.%s" : "%s[%s]") % [receiver, slot]
+        end
+      end
+      
+      class DotNode < OperatorNode # :nodoc:
+        def initialize(receiver, slot_equals, operation, expression)
+          @receiver, @slot, @operation, @expression = [receiver, slot_equals.to_s.gsub(/=/,''), operation, expression].build_nodes
+        end
+        
+        def compile_receiver(receiver, slot)
+          return "%s.%s" % [receiver, slot]
+        end
+      end
+      
+      class OrNode < OperatorNode # :nodoc:
+        def initialize(receiver, assignment_node_array)
+          @receiver, @slot, @operation, @expression = [receiver, nil, %s(||), assignment_node_array.last].build_nodes
+        end
+        
+        def compile_receiver(receiver, slot)
+          return "%s" % [receiver]
+        end
+        
+        def var?
+          return "var " unless [VariableNode::GlobalVariableNode, VariableNode::InstanceVariableNode].include?(@receiver.class)
+        end
+      end
+      
+      class AndNode < OperatorNode # :nodoc:
+        def initialize(receiver, assignment_node_array)
+          @receiver, @slot, @operation, @expression = [receiver, nil, %s(&&), assignment_node_array.last].build_nodes
+        end
+        
+        def compile_receiver(receiver, slot)
+          return "%s" % [receiver]
+        end
+        
+        def var?
+          return "var " unless [VariableNode::GlobalVariableNode, VariableNode::InstanceVariableNode].include?(@receiver.class)
+        end
+      end
+    end
+  end
+end

data/lib/red/call_nodes.rb

@@ -0,0 +1,85 @@
+module Red
+  class CallNode # :nodoc:
+    class BlockNode # :nodoc:
+      def initialize(receiver, arguments_array, expression = nil)
+        @receiver, @expression = [receiver, expression].build_nodes
+        @arguments = (((arguments_array ||= []).first == :masgn) ? arguments_array.assoc(:array)[1..-1].map {|node| node.last} : [arguments_array.last]).build_nodes
+      end
+      
+      def compile_node(options = {})
+        receiver = @receiver.compile_node.gsub(/\(\)$/,'')
+        arguments = @arguments.compile_nodes.join(', ')
+        expression = @expression.compile_node
+        case receiver.to_sym
+        when :lambda, :function, :proc
+          "function(%s) { %s }" % [arguments, expression]
+        else
+          "%s(function(%s) { %s })" % [receiver, arguments, expression]
+        end
+      end
+    end
+    
+    class MatchNode # :nodoc:
+      def initialize(regex, expression)
+        @regex, @expression = [regex, expression].build_nodes
+      end
+      
+      def compile_node(options = {}) # :nodoc:
+        regex = @regex.compile_node
+        expression = @expression.compile_node(:as_argument => true)
+        "%s.match(%s)" % [regex, expression]
+      end
+      
+      class ReverseNode < MatchNode # :nodoc:
+        def initialize(expression, regex)
+          @regex, @expression = [regex, expression].build_nodes
+        end
+      end
+    end
+    
+    class MethodNode # :nodoc:
+      def compile_node(options = {})
+        call_to_returned_function = [DefinitionNode::InstanceMethodNode, CallNode::BlockNode].include?(@receiver.class) ? :call : false
+        receiver = @receiver.compile_node
+        function = @function.compile_node
+        arguments = @arguments.compile_nodes(:as_argument => true, :quotes => "'")
+        return ("$%s(%s)" % [receiver = ((receiver == '$-') || (receiver == 'id' && @@red_library == :Prototype) ? nil : receiver), arguments.first]).gsub('$$','$').gsub('$class','$$') if @receiver.is_a?(VariableNode::GlobalVariableNode) && function == '-'
+        case function.to_sym
+        when :-, :+, :<, :>, :%, :*, :/, :^, :==, :===, :instanceof
+          "%s %s %s" % [receiver, function, arguments.first]
+        when :raise
+          "throw(%s)" % [arguments.first]
+        when :new
+          "new %s(%s)" % [receiver, arguments.join(', ')]
+        when :[]
+          if ([:symbol, :string].include?(@arguments.first.data_type) rescue false)
+            arguments = @arguments.compile_nodes(:quotes => "", :as_argument => true)
+            "%s.%s"
+          else
+            "%s[%s]"
+          end % [receiver, arguments.first]
+        when call_to_returned_function
+          "(%s)(%s)" % [receiver, arguments]
+        else
+          receiver += '.' unless receiver.empty?
+          "%s%s(%s)" % [receiver, function, arguments.join(', ')]
+        end
+      end
+      
+      class ExplicitNode < MethodNode # :nodoc:
+        def initialize(receiver, function, arguments = [nil])
+          @receiver, @function = [receiver, function].build_nodes
+          @arguments = arguments[1..-1].build_nodes
+        end
+      end
+      
+      class ImplicitNode < MethodNode # :nodoc:
+        def initialize(function, arguments = [nil])
+          @function = function.build_node
+          @receiver = (:self if @function.compile_node == '[]').build_node
+          @arguments = arguments[1..-1].build_nodes
+        end
+      end
+    end
+  end
+end

data/lib/red/conditional_nodes.rb

@@ -0,0 +1,63 @@
+module Red
+  class ConditionalNode # :nodoc:
+    class IfNode # :nodoc:
+      def initialize(condition, true_case, else_case)
+        @condition, @true_case, @else_case = [condition, true_case, else_case].build_nodes
+      end
+      
+      def compile_node(options = {})
+        unless options[:as_argument]
+          "if (%s) %s%s%s"
+        else
+          "(%s ? %s : %s)"
+        end % self.compile_internals(options)
+      end
+      
+      def compile_internals(options = {})
+        true_case, else_case, condition = [@true_case, @else_case, @condition].compile_nodes
+        return [condition, (true_case.empty? ? 'null' : true_case), (else_case.empty? ? 'null' : else_case)] if options[:as_argument]
+        condition = (true_case.empty? ? "!(%s)" : "%s") % [condition]
+        true_case = "{ %s; }" % [true_case] unless true_case.empty?
+        join      = " else "                      unless true_case.empty? || else_case.empty?
+        else_case = "{ %s; }" % [else_case] unless else_case.empty?
+        return [condition, true_case, join, else_case]
+      end
+    end
+    
+    class CaseNode # :nodoc:
+      def initialize(switch, *cases)
+        @switch, @else_case = [switch, cases.pop].build_nodes
+        @when_cases = cases.build_nodes
+      end
+      
+      def compile_node(options = {})
+        return "switch (%s) { %s%s }" % self.compile_internals
+      end
+      
+      def compile_internals(options = {})
+        switch, else_case = [@switch, @else_case].compile_nodes
+        when_cases = @when_cases.compile_nodes.join
+        default = "default:%s;" % [else_case] unless else_case.empty?
+        return [switch, when_cases, default]
+      end
+    end
+    
+    class WhenNode # :nodoc:
+      def initialize(conditions, expression)
+        @conditions = conditions[1..-1].build_nodes
+        @expression = expression.build_node
+      end
+      
+      def compile_node(options = {})
+        return "case %s:%s;%s" % self.compile_internals
+      end
+      
+      def compile_internals(options = {})
+        condition = @conditions.first.compile_node(:quotes => "'")
+        expression = @expression.compile_node
+        final = "break;"
+        return [condition, expression, final]
+      end
+    end
+  end
+end

data/lib/red/conjunction_nodes.rb

@@ -0,0 +1,23 @@
+module Red
+  class ConjunctionNode # :nodoc:
+    def initialize(a, b)
+      @a, @b = [a, b].build_nodes
+    end
+    
+    def compile_internals(options = {})
+      [@a, @b].compile_nodes(:as_argument => true)
+    end
+    
+    class AndNode < ConjunctionNode # :nodoc:
+      def compile_node(options = {})
+        return "%s && %s" % self.compile_internals
+      end
+    end
+    
+    class OrNode < ConjunctionNode # :nodoc:
+      def compile_node(options = {})
+        return "%s || %s" % self.compile_internals
+      end
+    end
+  end
+end

data/lib/red/constant_nodes.rb

@@ -0,0 +1,47 @@
+module Red
+  class ConstantNode # :nodoc:
+    class BreakNode < ConstantNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoBreakArguments, "Break can't take an argument in JavaScript") unless args.empty?
+      end
+      
+      def compile_node(options = {})
+        return "break"
+      end
+    end
+    
+    class FalseNode < ConstantNode # :nodoc:
+      def compile_node(options = {})
+        return "false"
+      end
+    end
+    
+    class NextNode < ConstantNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoNextArguments, "Next/continue can't take an argument in JavaScript") unless args.empty?
+      end
+      
+      def compile_node(options = {})
+        return "continue"
+      end
+    end
+    
+    class NilNode < ConstantNode # :nodoc:
+      def compile_node(options = {})
+        return "null"
+      end
+    end
+    
+    class SelfNode < ConstantNode # :nodoc:
+      def compile_node(options = {})
+        return "this"
+      end
+    end
+    
+    class TrueNode < ConstantNode # :nodoc:
+      def compile_node(options = {})
+        return "true"
+      end
+    end
+  end
+end

data/lib/red/control_nodes.rb

@@ -0,0 +1,127 @@
+module Red
+  class ControlNode # :nodoc:
+    class BeginNode # :nodoc:
+      def initialize(body)
+        @@rescue_is_safe = (body.first == :rescue)
+        @body = body.build_node
+      end
+      
+      def compile_node(options = {})
+        "%s" % [@body.compile_node]
+      end
+    end
+    
+    class EnsureNode # :nodoc:
+      def initialize(attempted, ensure_body)
+        @@rescue_is_safe = @ensure_from_rescue = attempted.first == :rescue
+        @attempted, @ensured = [attempted, ensure_body].build_nodes
+      end
+      
+      def compile_node(options = {})
+        if @ensure_from_rescue
+          "%s finally { %s; }" 
+        else
+          "try { %s; } finally { %s; }"
+        end % self.compile_internals
+      end
+      
+      def compile_internals(options = {})
+        return [@attempted, @ensured].compile_nodes
+      end
+    end
+    
+    class ForNode # :nodoc:
+      def initialize(source, iterator, body)
+        @properties_loop = (iterator.last == :property)
+        @source, @iterator, @body = [source, iterator.last, body].build_nodes
+      end
+      
+      def compile_node(options = {})
+        source = @source.compile_node(:as_argument => true)
+        iterator = @iterator.compile_node
+        body = @body.compile_node
+        if @properties_loop
+          "for (var property in %s) { %s; }" % [source, body]
+        else
+          "for (var %s = 0; %s < %s.length; %s++) { %s; }" % [iterator, iterator, source, iterator, body]
+        end
+      end
+    end
+    
+    class RescueNode # :nodoc:
+      def initialize(attempted, rescue_body)
+        raise(BuildError::NoArbitraryRescue, "JavaScript does not support arbitrary placement of rescue/try blocks") unless @@rescue_is_safe
+        raise(BuildError::NoSpecificRescue, "JavaScript does not support rescuing of specific exception classes") unless !rescue_body[1]
+        @@rescue_is_safe == false
+        @attempted = attempted.build_node
+        if (block = (rescue_body.assoc(:block) || [])[1..-1]) && block.first.last == [:gvar, %s($!)]
+          exception_node = block.shift
+          @exception_variable = exception_node[1].build_node
+          @rescued = block.unshift(:block).build_node
+        else
+          @exception_variable = :e.build_node
+          @rescued = rescue_body[2].build_node
+        end
+      end
+      
+      def compile_node(options = {})
+        return "try { %s; } catch(%s) { %s; }" % self.compile_internals
+      end
+      
+      def compile_internals(options = {})
+        return [@attempted, @exception_variable, @rescued].compile_nodes
+      end
+    end
+    
+    class UntilNode # :nodoc:
+      def initialize(condition, body, run_only_if_condition_met)
+        @condition, @body = [condition, body].build_nodes
+        @do_while_loop = !run_only_if_condition_met
+      end
+      
+      def compile_node(options = {})
+        if @do_while_loop
+          return "do { %s; } while (!(%s))" % self.compile_internals.reverse
+        else
+          return "while (!(%s)) { %s; }" % self.compile_internals
+        end
+      end
+      
+      def compile_internals(options = {})
+        condition, body = [@condition, @body].compile_nodes
+        return [condition, body]
+      end
+    end
+    
+    class WhileNode # :nodoc:
+      def initialize(condition, body, run_only_if_condition_met)
+        @condition, @body = [condition, body].build_nodes
+        @do_while_loop = !run_only_if_condition_met
+      end
+      
+      def compile_node(options = {})
+        if @do_while_loop
+          return "do { %s; } while (%s)" % self.compile_internals.reverse
+        else
+          return "while (%s) { %s; }" % self.compile_internals
+        end
+      end
+      
+      def compile_internals(options = {})
+        condition, body = [@condition, @body].compile_nodes
+        return [condition, body]
+      end
+    end
+    
+    class LibraryNode # :nodoc:
+      def initialize(library)
+        @@red_library = @library = library
+      end
+      
+      def compile_node(options = {})
+        @@red_library = @library
+        nil
+      end
+    end
+  end
+end