red 3.5.0 → 4.0.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: red
 version: !ruby/object:Gem::Version 
-  version: 3.5.0
+  version: 4.0.0
 platform: ruby
 authors: 
 - Jesse Sielaff
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-13 00:00:00 -04:00
+date: 2008-10-12 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,7 +42,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.7.0
     version: 
-description: Red is a Ruby-to-JavaScript transliterator using ParseTree.
+description: Red writes like Ruby and runs like JavaScript.
 email: 
 - jesse.sielaff@gmail.com
 executables: 
@@ -65,26 +65,21 @@ files:
 - 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
@@ -125,6 +120,6 @@ rubyforge_project: red-js
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: Red is a Ruby-to-JavaScript transliterator using ParseTree.
+summary: Red writes like Ruby and runs like JavaScript.
 test_files: []
 

data/lib/javascripts/_dom_ready.js

@@ -1,249 +0,0 @@
-// http://tanny.ica.com/ICA/TKO/test.nsf/js/addevent.js
-// Accessed 8/08/08 for Red
-
-// written by Dean Edwards, 2005
-// with input from Tino Zijdel, Matthias Miller, Diego Perini
-// http://dean.edwards.name/weblog/2005/10/add-event/
-// 2007-07-10 TKO - Removed check for body in schedule because of problems with Firefox 2.0
-
-/*global domReady */
-
-function addEvent(element, type, handler) {
-  // Modification by Tanny O'Haley, http://tanny.ica.com to add the
-  // DOMContentLoaded for all browsers.
-  if ((type === "DOMContentLoaded" || type === "domload")) {
-    if(typeof domReady === "function") {
-      domReady(handler);
-      return;
-    } else {
-      type = "load";
-    }
-  }
-  
-  if (element.addEventListener) {
-    element.addEventListener(type, handler, false);
-  } else {
-    // assign each event handler a unique ID
-    if (!handler.$$guid) {
-      handler.$$guid = addEvent.guid++;
-    }
-    // create a hash table of event types for the element
-    if (!element.events) {
-      element.events = {};
-    }
-    // create a hash table of event handlers for each element/event pair
-    var handlers = element.events[type];
-    if (!handlers) {
-      handlers = element.events[type] = {};
-      // store the existing event handler (if there is one)
-      if (element["on" + type]) {
-        handlers[0] = element["on" + type];
-      }
-    }
-    // store the event handler in the hash table
-    handlers[handler.$$guid] = handler;
-    // assign a global event handler to do all the work
-    element["on" + type] = handleEvent;
-  }
-}
-// a counter used to create unique IDs
-addEvent.guid = 1;
-
-function removeEvent(element, type, handler) {
-  if (element.removeEventListener) {
-    element.removeEventListener(type, handler, false);
-  } else {
-    // delete the event handler from the hash table
-    if (element.events && element.events[type]) {
-      delete element.events[type][handler.$$guid];
-    }
-  }
-}
-
-function handleEvent(event) {
-  var returnValue = true;
-  // grab the event object (IE uses a global event object)
-  event = event || fixEvent(((this.ownerDocument || this.document || this).parentWindow || window).event);
-  // get a reference to the hash table of event handlers
-  var handlers = this.events[event.type];
-  // execute each event handler
-  for (var i in handlers) {
-    this.$$handleEvent = handlers[i];
-    if (this.$$handleEvent(event) === false) {
-      returnValue = false;
-    }
-  }
-  return returnValue;
-}
-
-function fixEvent(event) {
-  // add W3C standard event methods
-  event.preventDefault = fixEvent.preventDefault;
-  event.stopPropagation = fixEvent.stopPropagation;
-  return event;
-}
-fixEvent.preventDefault = function() {
-  this.returnValue = false;
-};
-fixEvent.stopPropagation = function() {
-  this.cancelBubble = true;
-};
-
-// End Dean Edwards addEvent.
-
-// Tino Zijdel - crisp@xs4all.nl This little snippet fixes the problem that the onload attribute on 
-// the body-element will overwrite previous attached events on the window object for the onload event.
-if (!window.addEventListener) {
-  document.onreadystatechange = function(){
-    if (window.onload && window.onload !== handleEvent) {
-      addEvent(window, 'load', window.onload);
-      window.onload = handleEvent;
-    }
-  };
-}
-
-// -----------------------------------------------------
-// -----------------------------------------------------
-
-// http://tanny.ica.com/ICA/TKO/test.nsf/js/domready.js
-// Accessed 8/08/08 for Red
-
-// DOMContentLoaded event handler. Works for browsers that don't support the DOMContentLoaded event.
-//
-// Modification Log:
-// Date   Initial Description
-// 26 May 2008  TKO Created by Tanny O'Haley
-
-/*global addEvent, escape, unescape */
-
-var domReadyEvent = {
-  name: "domReadyEvent",
-  // Array of DOMContentLoaded event handlers.
-  events: {},
-  domReadyID: 1,
-  bDone: false,
-  DOMContentLoadedCustom: null,
-  
-  // Function that adds DOMContentLoaded listeners to the array.
-  add: function(handler) {
-    // Assign each event handler a unique ID. If the handler has an ID, it
-    // has already been added to the events object or been run.
-    if (!handler.$$domReadyID) {
-      handler.$$domReadyID = this.domReadyID++;
-      
-      // If the DOMContentLoaded event has happened, run the function.
-      if(this.bDone){
-        handler();
-      }
-      
-      // store the event handler in the hash table
-      this.events[handler.$$domReadyID] = handler;
-    }
-  },
-  
-  remove: function(handler) {
-    // Delete the event handler from the hash table
-    if (handler.$$domReadyID) {
-      delete this.events[handler.$$domReadyID];
-    }
-  },
-  
-  // Function to process the DOMContentLoaded events array.
-  run: function() {
-    // quit if this function has already been called
-    if (this.bDone) {
-      return;
-    }
-    
-    // Flag this function so we don't do the same thing twice
-    this.bDone = true;
-    
-    // iterates through array of registered functions 
-    for (var i in this.events) {
-      this.events[i]();
-    }
-  },
-  
-  schedule: function() {
-    // Quit if the init function has already been called
-    if (this.bDone) {
-      return;
-    }
-    
-    // First, check for Safari or KHTML.
-    if(/KHTML|WebKit/i.test(navigator.userAgent)) {
-      if(/loaded|complete/.test(document.readyState)) {
-        this.run();
-      } else {
-        // Not ready yet, wait a little more.
-        setTimeout(this.name + ".schedule()", 100);
-      }
-    } else if(document.getElementById("__ie_onload")) {
-      // Second, check for IE.
-      return true;
-    }
-    
-    // Check for custom developer provided function.
-    if(typeof this.DOMContentLoadedCustom === "function") {
-      //if DOM methods are supported, and the body element exists
-      //(using a double-check including document.body, for the benefit of older moz builds [eg ns7.1] 
-      //in which getElementsByTagName('body')[0] is undefined, unless this script is in the body section)
-      if(typeof document.getElementsByTagName !== 'undefined' && (document.getElementsByTagName('body')[0] !== null || document.body !== null)) {
-        // Call custom function.
-        if(this.DOMContentLoadedCustom()) {
-          this.run();
-        } else {
-          // Not ready yet, wait a little more.
-          setTimeout(this.name + ".schedule()", 250);
-        }
-      }
-    }
-    
-    return true;
-  },
-  
-  init: function() {
-    // If addEventListener supports the DOMContentLoaded event.
-    if(document.addEventListener) {
-      document.addEventListener("DOMContentLoaded", function() { domReadyEvent.run(); }, false);
-    }
-    
-    // Schedule to run the init function.
-    setTimeout("domReadyEvent.schedule()", 100);
-    
-    function run() {
-      domReadyEvent.run();
-    }
-    
-    // Just in case window.onload happens first, add it to onload using an available method.
-    if(typeof addEvent !== "undefined") {
-      addEvent(window, "load", run);
-    } else if(document.addEventListener) {
-      document.addEventListener("load", run, false);
-    } else if(typeof window.onload === "function") {
-      var oldonload = window.onload;
-      window.onload = function() {
-        domReadyEvent.run();
-        oldonload();
-      };
-    } else {
-      window.onload = run;
-    }
-    
-    /* for Internet Explorer */
-    /*@cc_on
-      @if (@_win32 || @_win64)
-      document.write("<script id=__ie_onload defer src=\"//:\"><\/script>");
-      var script = document.getElementById("__ie_onload");
-      script.onreadystatechange = function() {
-        if (this.readyState == "complete") {
-          domReadyEvent.run(); // call the onload handler
-        }
-      };
-      @end
-    @*/
-  }
-};
-
-var domReady = function(handler) { domReadyEvent.add(handler); };
-domReadyEvent.init();

data/lib/javascripts/prototype_dom_ready.js

@@ -1 +0,0 @@
-var domReady = function(handler) { document.observe('dom:loaded', handler); };

data/lib/javascripts/red/unobtrusive.red

@@ -1,6 +0,0 @@
-# To enable DOM-ready functionality, be sure the <head> of your layout contains:
-# <script type="text/javascript" src="/javascripts/dom_ready.js"></script>
-# <script type="text/javascript" src="/javascripts/unobtrusive.js"></script>
-dom_ready do
-  # The contents of this block will be executed when the DOM is finished loading.
-end

data/lib/red/assignment_nodes.rb

@@ -1,164 +0,0 @@
-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
-    
-    def compile_increment(options = {})
-      return "%s%s" % [options[:receiver] || @variable_name.compile_node, @expression.increment_operator * 2]
-    end
-    
-    def call_to_increment?
-      return @expression.increment_operator rescue false
-    end
-    
-    class ClassVariableNode < AssignmentNode  # :nodoc:
-      def compile_node(options = {})
-        expression = @expression.compile_node(:as_argument => true)
-        if options[:as_prototype]
-          receiver = @variable_name.compile_node
-          "%s: %s"
-        else
-          receiver = "%s.%s" % [@@red_class, @variable_name.compile_node]
-          return self.compile_increment(:receiver => receiver) if self.call_to_increment?
-          "%s = %s"
-        end % [receiver, expression]
-      end
-    end
-    
-    class GlobalVariableNode < AssignmentNode  # :nodoc:
-      def compile_node(options = {})
-        return self.compile_increment if self.call_to_increment?
-        return "%s = %s" % self.compile_internals
-      end
-    end
-    
-    class InstanceVariableNode < AssignmentNode # :nodoc:
-      def compile_node(options = {})
-        receiver = "this.%s" % @variable_name.compile_node
-        return self.compile_increment(:receiver => receiver) if self.call_to_increment?
-        return "%s = %s" % [receiver, @expression.compile_node(:as_argument => true)]
-      end
-    end
-    
-    class LocalVariableNode < AssignmentNode # :nodoc:
-      def compile_node(options = {})
-        return self.compile_increment if self.call_to_increment?
-        return (@variable_name.is_a?(LiteralNode::NamespaceNode) || options[:skip_var] ? "%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 = {})
-        expression = @expression.compile_node(:as_argument => true)
-        receiver = self.compile_receiver
-        return [receiver, expression]
-      end
-      
-      def compile_receiver
-        variable_name = @variable_name.compile_node
-        if [:symbol, :string].include?((@slot.data_type rescue :node))
-          slot = @slot.compile_node(:quotes => '')
-          "%s.%s"
-        else
-          slot = @slot.compile_node
-          "%s[%s]"
-        end % [variable_name, slot]
-      end
-    end
-    
-    class OperatorNode # :nodoc:
-      def compile_node(options = {})
-        return self.compile_increment if self.call_to_increment?
-        return "%s%s = %s %s %s" % self.compile_internals
-      end
-      
-      def compile_increment(options = {})
-        receiver, operation = [@receiver, @operation].compile_nodes
-        slot = @slot.compile_node(:quotes => '')
-        original = self.compile_receiver(receiver, slot)
-        return "%s%s" % [original, operation * 2]
-      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
-      
-      def call_to_increment?
-        return ['+', '-'].include?(@operation.compile_node) && @expression.compile_node == '1'
-      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)
-          if [:symbol, :string].include?((@slot.data_type rescue :node))
-            "%s.%s"
-          else
-            slot = @slot.compile_node(:quotes => "'")
-            "%s[%s]"
-          end % [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, VariableNode::ClassVariableNode].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, VariableNode::ClassVariableNode].include?(@receiver.class)
-        end
-      end
-    end
-  end
-end

data/lib/red/call_nodes.rb

@@ -1,90 +0,0 @@
-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 = {})
-        receiver = @receiver.compile_node
-        function = @function.compile_node(:quotes => '')
-        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, :in
-          "(%s %s %s)" % [receiver, function, arguments.first]
-        when :raise
-          "throw(%s)" % [arguments.first]
-        when :new
-          "new %s(%s)" % [receiver, arguments.join(', ')]
-        when :var
-          "var %s" % [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 :_
-          "%s(%s)" % [receiver, arguments]
-        else
-          receiver += '.' unless receiver.empty?
-          "%s%s(%s)" % [receiver, function, arguments.join(', ')]
-        end
-      end
-      
-      def increment_operator
-        return @function.compile_node if ['+', '-'].include?(@function.compile_node) && @arguments.first.compile_node == '1'
-      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

@@ -1,63 +0,0 @@
-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.compile_node(:as_argument => true)), (else_case.empty? ? 'null' : @else_case.compile_node(:as_argument => true))] 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

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