red 3.5.0 → 4.0.0

data/History.txt

@@ -1,3 +1,7 @@
+== 4.0.0 2008-10-12
+
+* New version released.
+
 == 3.5.0 2008-08-13
 
 * 2 major enhancements:

data/Manifest.txt

@@ -7,26 +7,21 @@ Rakefile
 bin/red
 config/hoe.rb
 config/requirements.rb
-lib/javascripts/_dom_ready.js
-lib/javascripts/prototype_dom_ready.js
-lib/javascripts/red/unobtrusive.red
 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/executable.rb
-lib/red/illegal_nodes.rb
-lib/red/literal_nodes.rb
 lib/red/plugin.rb
-lib/red/variable_nodes.rb
 lib/red/version.rb
-lib/red/wrap_nodes.rb
+lib/red/nodes/assignment_nodes.rb
+lib/red/nodes/call_nodes.rb
+lib/red/nodes/control_nodes.rb
+lib/red/nodes/data_nodes.rb
+lib/red/nodes/definition_nodes.rb
+lib/red/nodes/illegal_nodes.rb
+lib/red/nodes/literal_nodes.rb
+lib/red/nodes/logic_nodes.rb
+lib/red/nodes/variable_nodes.rb
+lib/source/ruby.rb
 script/console
 script/destroy
 script/generate

data/README.txt

@@ -1,59 +1,16 @@
-= Turn your JavaScript <span style="color:rgb(195,0,0)">Red</span>.
+= Write Ruby. Run JavaScript. The new Red is here.
 
-<span style="color:rgb(195,0,0)">Red</span> is a Ruby-to-JavaScript transliterator built on <a href=http://rubyforge.org/projects/parsetree/>ParseTree</a>.
+Red takes the Ruby you write and turns it into JavaScript for your browser.
 
-=== Installation
-
-To get <span style="color:rgb(195,0,0)">Red</span> working, install the rubygem.
-<pre>sudo gem install red</pre>
-
-=== Creating <tt>.js</tt> Files
-
-Create a new <tt>.red</tt> file and edit it using your text editor.
-  $ mate example.red
-  
-  1| class Foo
-  2|   def initialize(foo)
-  3|     @foo = foo
-  4|   end
-  5| end
-
-Use the command-line executable to convert your Ruby into JavaScript.
-
-  $ red example
-  #=> var Foo = function(foo) { this.foo = foo; }
-
-<span style="color:rgb(195,0,0)">Red</span> creates a <tt>.js</tt> file containing the output.
-
-  $ ls
-  #=> example.js   example.red
+The all-new Red is a Ruby-to-JavaScript transliterator backed by a custom ruby.js library designed to let your code run in the browser exactly* the way Ruby would run on your machine. The JavaScript output is optimized to contain only the fraction of the ruby.js source library needed to run your code.
 
-=== Previewing your JavaScript output
+What does this mean for today’s Ruby developer? Simple. You don’t need to learn JavaScript.
 
-If you want to see what JavaScript a snippet of Ruby code will produce without creating a <tt>.js</tt> file, use the special filename <tt>test.red</tt>.
-
-  $ mate test.red
-  
-  1| return false unless navigator[:user_agent].index_of('AppleWebKit/') > -1
-  
-  $ red test
-  #=> if (!(navigator.userAgent.indexOf('AppleWebKit/') > -1)) { return false; }
-  
-  $ ls
-  #=> example.js   example.red   test.red
-
-You can test short code snippets from the command line without creating a test file by using the <tt>-s</tt> option.
-
-  $ red -s "@foo"
-  #=> this.foo
-
-=== Tutorial
-
-Check the <a href=http://github.com/jessesielaff/red/wikis/tutorial>Tutorial page</a> for an in-depth lesson in how to use <span style="color:rgb(195,0,0)">Red</span> to write your JavaScript in Ruby.
+=== Installation
 
-=== Documentation
+To get Red working, install the rubygem.
 
-The <a href=http://red-js.rubyforge.org/red/rdoc/>documentation</a> is currently rather nonexistent.
+  sudo gem install red
 
 === Bugs / Issues
 

data/bin/red

@@ -1,14 +1,9 @@
 #!/usr/bin/env ruby
-# Red's command line transliterator executable.
+# Red's command line Ruby-to-JS conversion executable.
 # 
 # Copyright (c) 2008 Jesse Sielaff.
 
-begin
-  require 'rubygems'
-rescue LoadError
-  # no rubygems to load, so we fail silently
-end
-
+require 'rubygems' rescue nil
 require 'red'
 require 'red/executable'
 require 'red/version'
@@ -20,11 +15,11 @@ include Red
 parser = OptionParser.new do |opts|
   opts.banner = RED_MESSAGES[:banner]
   opts.separator ""
-  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
-  opts.on("-r", "--rails", "Add Red plugin to ./vendor/plugins.") { build_red_plugin_for_rails }
-  opts.on("-s", "--string=RUBY_STRING", "Translate a single string to JavaScript.") { |string| direct_translate(string) }
-  opts.on("-u", "--unobtrusive [LIBRARY]", "Add support for unobtrusive JavaScript to your Rails project.") { |library| add_unobtrusive(library) }
-  opts.on("-v", "--version", "Print version number.") { puts Red::VERSION::STRING; exit }
+  opts.on('-h',"--help","Show this help message.")                                    { puts opts; exit }
+  opts.on('-r',"--rails","Add Red plugin to ./vendor/plugins.")                       { build_red_plugin_for_rails }
+  opts.on('-s',"--string=RUBY_STRING","Translate a single string to JavaScript.")     { |string| Red.init && direct_translate(string) }
+  opts.on('-t',"--test","Translate a file to JavaScript without writing a .js file.") { ARGV.push(:test) }
+  opts.on('-v',"--version","Print version number.")                                   { puts Red::VERSION::STRING; exit }
   begin
     opts.parse!(ARGV)
   rescue OptionParser::InvalidOption => e
@@ -34,10 +29,8 @@ parser = OptionParser.new do |opts|
   end
 end
 
-if ARGV.empty?
-  puts RED_MESSAGES[:usage]; exit
-else
-  class << Red
-    self.compile_red_to_js(ARGV[0])
-  end
-end
+class << Red
+  dry_run = (ARGV[1] ? ARGV.pop : true) if Red.init && ARGV.last == :test
+  ARGV.map {|filename| self.convert_red_file_to_js(filename, dry_run)}
+end && exit unless ARGV.empty?
+puts RED_MESSAGES[:usage]

data/config/hoe.rb

@@ -2,7 +2,7 @@ require 'red/version'
 
 AUTHOR = 'Jesse Sielaff'
 EMAIL = "jesse.sielaff@gmail.com"
-DESCRIPTION = "Red is a Ruby-to-JavaScript transliterator using ParseTree."
+DESCRIPTION = "Red writes like Ruby and runs like JavaScript."
 GEM_NAME = 'red'
 RUBYFORGE_PROJECT = 'red-js'
 HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
@@ -36,11 +36,12 @@ 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"]
+RDOC_OPTS = [
+  "--quiet",
+  "--title", "red documentation",
+  "--opname", "index.html",
+  "--line-numbers"
+]
 
 class Hoe
   def extra_deps

data/lib/red/errors.rb

@@ -1,43 +1,15 @@
 module Red
   class BuildError < StandardError # :nodoc:
-    # Raised when a hash is given a key other than a +String+ or +Symbol+
-    # object.
-    class NoArbitraryHashKeys < BuildError # :nodoc:
-    end
-    
     # Raised when a lone +Regex+ is used as a condition.
     class NoArbitraryMatch < BuildError # :nodoc:
     end
     
-    # Raised when a +rescue+ block is placed in a way that would produce a
-    # JavaScript syntax error.
-    class NoArbitraryRescue < BuildError # :nodoc:
-    end
-    
     # Raised when a +BEGIN+ or +END+ block is used.
     class NoBEGINorEND < BuildError # :nodoc:
     end
     
-    # Raised when a block is declared as a method argument.
-    class NoBlockArguments < BuildError # :nodoc:
-    end
-    
-    # Raised when a +break+ keyword is followed by an argument.
-    class NoBreakArguments < BuildError # :nodoc:
-    end
-    
-    # Raised when the active JavaScript library does not support class
-    # inheritance.
-    class NoClassInheritance < BuildError # :nodoc:
-    end
-    
-    # Raised when the active JavaScript library does not support calls to
-    # class variables or declarations of class variables.
-    class NoClassVariables < BuildError # :nodoc:
-    end
-    
-    # Raised when a +redo+ or +retry+ keyword is used.
-    class NoDoOvers < BuildError # :nodoc:
+    # Raised when a +retry+ keyword is used.
+    class NoRetry < BuildError # :nodoc:
     end
     
     # Raised when a flipflop operator is called using <tt>..</tt> or
@@ -45,49 +17,15 @@ module Red
     class NoFlipflops < BuildError # :nodoc:
     end
     
-    # Raised when a +begin+ block is used for multiline assignment.
-    class NoMultilineAssignment < BuildError # :nodoc:
-    end
-    
-    # Raised when a comma-separated multiple assignment expression is used.
-    class NoMultipleAssignment < BuildError # :nodoc:
-    end
-    
-    # Raised when a +break+ keyword is followed by an argument.
-    class NoNextArguments < BuildError # :nodoc:
-    end
-    
-    # Raised when the active JavaScript library has no native literal range
-    # constructor.
-    class NoRangeConstructor < BuildError # :nodoc:
-    end
-    
     # Raised when a +Regex+ literal declaration contains evaluated content.
     class NoRegexEvaluation < BuildError # :nodoc:
     end
     
-    # Raised when an +Error+ class is passed to +rescue+.
-    class NoSpecificRescue < BuildError # :nodoc:
-    end
-    
     # Raised when the active JavaScript library has no special array
     # constructor.
     class NoSplatConstructor < BuildError # :nodoc:
     end
     
-    # Raised when the active JavaScript library does not support calls to
-    # +super+.
-    class NoSuperMethods < BuildError # :nodoc:
-    end
-    
-    # Raised when a +Symbol+ literal declaration contains evaluated content.
-    class NoSymbolEvaluation < BuildError # :nodoc:
-    end
-    
-    # Raised when an +undef+ keyword is used.
-    class NoUndef < BuildError # :nodoc:
-    end
-    
     # Raised when an unknown ParseTree sexp type is called to initialize.
     class UnknownNode < BuildError # :nodoc:
     end

data/lib/red/executable.rb

@@ -6,22 +6,20 @@ module Red # :nodoc:
     self.make_plugin_directory('public/javascripts/red')
     
     return unless display_message
-    puts @files
-    exit
+    puts @files && exit
   end
   
-  def add_unobtrusive(library)
-    @files ||= ''
-    self.build_red_plugin_for_rails(false)
-    self.create_plugin_file(:copy, 'public/javascripts/dom_ready.js', File.join(File.dirname(__FILE__), "../javascripts/#{(library || '').downcase}_dom_ready.js"))
-    self.create_plugin_file(:copy, 'public/javascripts/red/unobtrusive.red', File.join(File.dirname(__FILE__), "../javascripts/red/unobtrusive.red"))
-    
-  rescue Errno::ENOENT
-    puts "There is no Unobtrusive Red support for #{library}"
-  ensure
-    puts @files
-    exit
-  end
+  # def add_unobtrusive(library)
+  #   @files ||= ''
+  #   self.build_red_plugin_for_rails(false)
+  #   self.create_plugin_file(:copy, 'public/javascripts/dom_ready.js', File.join(File.dirname(__FILE__), "../javascripts/#{(library || '').downcase}_dom_ready.js"))
+  #   self.create_plugin_file(:copy, 'public/javascripts/red/unobtrusive.red', File.join(File.dirname(__FILE__), "../javascripts/red/unobtrusive.red"))
+  #   
+  # rescue Errno::ENOENT
+  #   puts "There is no Unobtrusive Red support for #{library}"
+  # ensure
+  #   puts @files && exit
+  # end
   
   def make_plugin_directory(dir, only_this_directory = false)
     parent_dir = File.dirname(dir)
@@ -29,8 +27,7 @@ module Red # :nodoc:
     directory_status = File.exists?(dir) ? 'exists' : Dir.mkdir(dir) && 'create'
     @files << "      %s  %s\n" % [directory_status, dir]
   rescue SystemCallError
-    puts "Unable to create directory in #{parent_dir}"
-    exit
+    puts "Unable to create directory in #{parent_dir}" && exit
   end
   
   def create_plugin_file(operation, filename, contents)
@@ -52,8 +49,7 @@ module Red # :nodoc:
   end
   
   def direct_translate(string)
-    js_output = hush_warnings { string.string_to_node }.compile_node
-    print_js(js_output, 'test')
+    print_js(hush_warnings { string.translate_to_sexp_array }.red!)
     exit
   end
   
@@ -61,35 +57,41 @@ module Red # :nodoc:
     $stderr = File.open('spew', 'w')
     output = yield
     $stderr = $>
-    
     File.delete('spew')
-    
     return output
   end
   
-  def print_js(js_output, filename) # :nodoc:
-    puts RED_MESSAGES[:output] % [("- #{filename}.js" unless filename == 'test'), js_output, @@red_errors ||= '']
-  end
-  
-  def compile_red_to_js(filename)
+  def convert_red_file_to_js(filename, dry_run = false)
     unless File.exists?(file = "%s.red" % [filename]) || File.exists?(file = "%sred/%s.red" % [(dir = "public/javascripts/"), filename])
       puts "File #{filename}.red does not exist."
       exit
     end
-    
-    source = File.read(file)
-    js_output = hush_warnings { source.string_to_node }.compile_node
-    
-    File.open("%s%s.js" % [dir, filename], 'w') {|f| f.write(js_output)} unless filename == 'test'
-    
-    print_js(js_output, filename)
+    js_output = hush_warnings { File.read(file).translate_to_sexp_array }.red!
+    ruby_js   = compile_ruby_js_source
+    File.open("%s%s.js" % [dir, filename], 'w') {|f| f.write(ruby_js + js_output)} unless dry_run
+    print_js(js_output, filename, dry_run)
+  end
+  
+  def compile_ruby_js_source
+    cache_known_constants = @@red_constants
+    @@red_constants = []
+    @@red_import = true
+    ruby_js = hush_warnings { File.read(File.join(File.dirname(__FILE__), "../source/ruby.rb")).translate_to_sexp_array }.red!
+    @@red_constants = cache_known_constants
+    @@red_methods = INTERNAL_METHODS
+    @@red_import = false
+    return ruby_js
+  end
+  
+  def print_js(js_output, filename = nil, dry_run = true) # :nodoc:
+    puts RED_MESSAGES[:output] % [("- #{filename}.js" unless dry_run), js_output]
   end
   
   RED_MESSAGES = {}
   RED_MESSAGES[:banner] = <<-MESSAGE
 
 Description:
-  Red is a Ruby-to-JavaScript transliterator.
+  Red converts Ruby to JavaScript.
   For more information see http://github.com/jessesielaff/red/wikis
 
 Usage: red [filename] [options]
@@ -129,7 +131,6 @@ Use red -h for help.
 %s
 
 =================================
-%s
 
   MESSAGE
 end

data/lib/red/nodes/assignment_nodes.rb

@@ -0,0 +1,133 @@
+module Red
+  class AssignmentNode < String # :nodoc:
+    class ClassVariable < AssignmentNode  # :nodoc:
+      # [:cvdecl, :@@foo, {expression}] => inside eval portion of class declaration
+      # [:cvasgn, :@@foo, {expression}] => inside method definition
+      def initialize(variable_name_sexp, expression_sexp, options)
+        class_name    = @@namespace_stack.join(".")
+        variable_name = variable_name_sexp.red!
+        expression    = expression_sexp.red!(:as_argument => true)
+        self << "%s.cvset('%s',%s)" % [class_name, variable_name, expression]
+      end
+    end
+    
+    class Constant < AssignmentNode # :nodoc:
+      # [:cdecl, :Foo, {expression}]
+      def initialize(constant_name_sexp, expression_sexp, options)
+        constant_name    = (@@namespace_stack + ["c$%s" % constant_name_sexp.red!]).join(".")
+        @@red_constants |= [constant_name]
+        expression       = expression_sexp.red!(:as_assignment => true)
+        self << "%s=%s" % [constant_name, expression]
+      end
+    end
+    
+    class GlobalVariable < AssignmentNode  # :nodoc:
+      # [:gasgn, :$foo, {expression}]
+      def initialize(variable_name_sexp, expression_sexp, options)
+        variable_name = variable_name_sexp.red!
+        expression    = expression_sexp.red!(:as_assignment => true)
+        self << "%s=%s" % [variable_name, expression]
+      end
+    end
+    
+    class InstanceVariable < AssignmentNode # :nodoc:
+      # [:iasgn, :@foo, {expression}]
+      def initialize(variable_name_sexp, expression_sexp, options)
+        variable_name = variable_name_sexp.red!
+        expression    = expression_sexp.red!(:as_assignment => true)
+        self << "this.i$%s=%s" % [variable_name, expression]
+      end
+    end
+    
+    class LocalVariable < AssignmentNode # :nodoc:
+      # [:lasgn,      :foo, {expression}]
+      # [:dasgn,      :foo, {expression}] => previously defined inside a proc, but not the nearest proc
+      # [:dasgn_curr, :foo, {expression}] => local to the nearest proc
+      def initialize(variable_name_sexp, expression_sexp, options)
+        variable_name = variable_name_sexp.red!
+        expression    = expression_sexp.red!(:as_assignment => true)
+        if options[:as_argument_default]
+          self << "%s=$T(_a=%s)?_a:%s" % [variable_name, variable_name, expression]
+        else
+          self << "%s=%s" % [variable_name, expression]
+        end
+      end
+    end
+    
+    class Attribute < AssignmentNode # :nodoc:
+      # [:attrasgn, {expression}, :foo= | :[]=, [:array, {element}, {element}, ...]]
+      def initialize(receiver_sexp, writer_sexp, arguments_array_sexp, options)
+        receiver  = receiver_sexp.red!(:as_receiver => true)
+        writer    = (METHOD_ESCAPE[writer_sexp] || writer_sexp).red!
+        arguments = arguments_array_sexp[1..-1].map {|argument_sexp| argument_sexp.red!(:as_argument => true) }.join(",")
+        self << "%s.m$%s(%s)" % [receiver, writer, arguments]
+      end
+    end
+    
+    class Multiple < AssignmentNode # :nodoc:
+      # [:masgn, [:array, {expression}, {expression} ...], [:to_ary, {expression}] | [:array, {expression}, {expression}, ...]]
+      def initialize(variables_array_sexp, assignments_array_sexp)
+        variables = variables_array_sexp[1..-1].map {|variable_sexp| variable_sexp.last.red! }
+        self << ""
+      end
+    end
+    
+    class Operator < AssignmentNode # :nodoc:
+      class Bracket < Operator # :nodoc:
+        # [:op_asgn_1, {expression}, [:array, {element}, {element} ...], :+ | :* |..., {expression}] => from e.g. "foo[bar] ||= 1"
+        def initialize(receiver_sexp, arguments_array_sexp, method_sexp, expression_sexp, options)
+          receiver   = receiver_sexp.red!(:as_receiver => true)
+          arguments  = arguments_array_sexp[1..-1].map {|argument_sexp| argument_sexp.red!(:as_argument => true) }.join(",")
+          comma      = arguments.empty? ? "" : ","
+          method     = (METHOD_ESCAPE[method_sexp] || method_sexp).red!
+          expression = expression_sexp.red!(:as_argument => true)
+          object     = "%s.m$_brkt(%s)" % [receiver, arguments]
+          unless string = ((method == '||' && LogicNode::Conjunction::Or::STRING) || (method == '&&' && LogicNode::Conjunction::And::STRING))
+            operation = "%s.m$%s(%s)" % [object, method, expression]
+          else
+            operation = string % [object, expression]
+          end
+          self << "%s.m$_breq(%s%s%s)" % [receiver, arguments, comma, operation]
+        end
+      end
+      
+      class Dot < Operator # :nodoc:
+        # [:op_asgn_2, {expression}, :foo=, :+ | :* |..., {expression}] => from e.g. "foo.bar ||= 1"
+        def initialize(receiver_sexp, writer_sexp, method_sexp, expression_sexp, options)
+          receiver   = receiver_sexp.red!(:as_receiver => true)
+          reader     = writer_sexp.to_s.gsub(/=/,'').to_sym.red!
+          writer     = writer_sexp.red!
+          method     = (METHOD_ESCAPE[method_sexp] || method_sexp).red!
+          expression = expression_sexp.red!(:as_argument => true)
+          object     = "%s.m$%s()" % [receiver, reader]
+          unless string = ((method == '||' && LogicNode::Conjunction::Or::STRING) || (method == '&&' && LogicNode::Conjunction::And::STRING))
+            operation = "%s.m$%s(%s)" % [object, method, expression]
+          else
+            operation = string % [object, expression]
+          end
+          self << "%s.m$%s(%s)" % [receiver, writer, operation]
+        end
+      end
+      
+      class Or < Operator # :nodoc:
+        # [:op_asgn_or, {expression}, {expression}] => from e.g. "foo ||= 1"
+        def initialize(variable_name_sexp, assignment_sexp, options)
+          variable_name = variable_name_sexp.red!
+          expression    = assignment_sexp.last.red!(:as_argument => true)
+          conjunction   = LogicNode::Conjunction::Or::STRING % [variable_name, expression]
+          self << "%s=%s" % [variable_name, conjunction]
+        end
+      end
+      
+      class And < Operator # :nodoc:
+        # [:op_asgn_and, {expression}, {expression}] => from e.g. "foo &&= 1"
+        def initialize(variable_name_sexp, assignment_sexp, options)
+          variable_name = variable_name_sexp.red!
+          expression    = assignment_sexp.last.red!(:as_argument => true)
+          conjunction   = LogicNode::Conjunction::And::STRING % [variable_name, expression]
+          self << "%s=%s" % [variable_name, conjunction]
+        end
+      end
+    end
+  end
+end

data/lib/red/nodes/call_nodes.rb

@@ -0,0 +1,126 @@
+module Red
+  class CallNode < String # :nodoc:
+    class Ampersand < CallNode # :nodoc:
+      # [:block_pass, {expression}, {expression}]
+      def initialize(block_pass_sexp, function_call_sexp, options)
+        block_string = "%s.m$toProc()._block" % block_pass_sexp.red!(:as_receiver => true)
+        function_call = function_call_sexp.red!(options.merge(:block_string => block_string))
+        self << "%s" % [function_call]
+      end
+    end
+    
+    class Block < CallNode # :nodoc:
+      # [:iter, {expression}, {0 | :dasgn_curr | :masgn, [:array, {:dasgn_curr, :dasgn_curr, ...}]}, (expression | :block)]
+      def initialize(function_call_sexp, block_arguments_array_sexp, block_body_sexp = nil, options = {})
+        (options = block_body_sexp) && (block_body_sexp = [:block, [:nil]]) if block_body_sexp.is_a?(::Hash)
+        block_arguments = block_arguments_array_sexp.is_sexp?(:masgn) ? block_arguments_array_sexp.assoc(:array)[1..-1].map {|dasgn_curr| dasgn_curr.last.red! }.join(",") : (block_arguments_array_sexp && block_arguments_array_sexp != 0 ? block_arguments_array_sexp.last : nil).red!
+        block_body      = (block_body_sexp.is_sexp?(:block) ? block_body_sexp : [:block, block_body_sexp]).red!(:force_return => true)
+        block_string    = "function(%s){%s;}" % [block_arguments, block_body]
+        block_string   << ".m$(this)" unless [:instance_eval, :class_eval].include?(function_call_sexp.last)
+        function_call   = function_call_sexp.red!(options.merge(:block_string => block_string))
+        self << "%s" % [function_call]
+      end
+    end
+    
+    class Defined < CallNode # :nodoc:
+      # [:defined, {expression}]
+      def initialize(expression_sexp, options)
+        expression = expression_sexp.red!(:as_argument => true)
+        self << "!(typeof(%s)=='undefined')" % [expression]
+      end
+    end
+    
+    class Match # :nodoc:
+    # # [:match2, {expression}, {expression}] => when first expression is RegExp e.g. /foo/ =~ foo | /foo/ =~ /foo/
+    # 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 Reverse < Match # :nodoc:
+      # # [:match3, {expression}, {expression}] => when only second expression is RegExp e.g. foo =~ /foo/
+      # def initialize(expression, regex)
+      #   @regex, @expression = [regex, expression].build_nodes
+      # end
+      end
+    end
+    
+    class Method < CallNode # :nodoc:
+      class ExplicitReceiver < Method # :nodoc:
+        # [:call, {expression}, :foo, (:array, {expression}, {expression}, ...)]
+        def initialize(receiver_sexp, function_sexp, *arguments_array_sexp)
+          options     = arguments_array_sexp.pop
+          receiver    = receiver_sexp.red!(:as_receiver => true)
+          function    = (METHOD_ESCAPE[function_sexp] || function_sexp).red!
+          args_array  = arguments_array_sexp.last.is_sexp?(:array) ? arguments_array_sexp.last[1..-1].map {|argument_sexp| argument_sexp.red!(:as_argument => true)} : []
+          args_array += [options[:block_string]] if options[:block_string]
+          arguments   = args_array.join(",")
+          self << "%s.m$%s(%s)" % [receiver, function, arguments]
+          @@red_methods |= [function_sexp] unless @@red_import
+        end
+      end
+      
+      class ImplicitReceiver < Method # :nodoc:
+        # [:fcall, :foo, (:array, {expression}, {expression}, ...)]
+        def initialize(function_sexp, *arguments_array_sexp)
+          options     = arguments_array_sexp.pop
+          function    = (METHOD_ESCAPE[function_sexp] || function_sexp).red!
+          args_array  = arguments_array_sexp.last.is_sexp?(:array) ? arguments_array_sexp.last[1..-1].map {|argument_sexp| argument_sexp.red!(:as_argument => true)} : []
+          args_array += [options[:block_string]] if options[:block_string]
+          arguments   = args_array.join(",")
+          case function_sexp
+          when :require
+            #cached_import_status = @@red_import
+            #@@red_import = true
+            self << hush_warnings { File.read((arguments_array_sexp.assoc(:array).assoc(:str).last rescue '')).translate_to_sexp_array }.red!
+            #@@red_import = cached_import_status
+          when :[]
+            self << "this.m$%s(%s)" % [function, arguments]
+          when :block_given?
+            self << "m$blockGivenBool(%s._block)" % @@red_block_arg
+          else
+            self << "(this.m$%s||m$%s).call(this,%s)" % [function, function, arguments]
+            @@red_methods |= [function_sexp] unless @@red_import
+          end
+        end
+      end
+    end
+    
+    class Super < CallNode # :nodoc:
+      # [:super, (:array, {expression}, {expression}, ...)]
+      def initialize(*arguments_array_sexp)
+        options     = arguments_array_sexp.pop
+        args_array  = arguments_array_sexp.last.is_sexp?(:array) ? arguments_array_sexp.last[1..-1].map {|argument_sexp| argument_sexp.red!(:as_argument => true)} : []
+        args_array  = ["this"] + args_array
+        args_array += [options[:block_string]] if options[:block_string]
+        arguments   = args_array.join(",")
+        self << "this.m$class().m$superclass().prototype.m$%s.call(%s)" % [@@red_function, arguments]
+      end
+      
+      class Delegate < Super # :nodoc:
+        # [:zsuper]
+        # FIX: Super::Delegate ignores block_string option when called inside an :iter e.g. super { foo }; this is an easy enough fix but annoying in that it needs fixing
+        def initialize(*arguments_array_sexp)
+          options = arguments_array_sexp.pop
+          self << "this.m$class().m$superclass().prototype.m$%s.apply(this,arguments)" % [@@red_function]
+        end
+      end
+    end
+    
+    class Yield < CallNode # :nodoc:
+      # [:yield, (expression | :array, {expression}, {expression}, ...)]
+      def initialize(arguments_array_sexp = nil, options = {})
+        (options = arguments_array_sexp) && (arguments_array_sexp = [:array]) if arguments_array_sexp.is_a?(Hash)
+        argument_sexps = arguments_array_sexp.is_sexp?(:array) ? arguments_array_sexp[1..-1] || [] : [arguments_array_sexp]
+        args_array     = argument_sexps.map {|argument_sexp| argument_sexp.red!(:as_argument => true)}
+        arguments      = args_array.join(",")
+        self << "%s.m$call(%s)" % [@@red_block_arg, arguments]
+      end
+    end
+  end
+end