red 3.0.0

data/lib/red/data_nodes.rb

@@ -0,0 +1,92 @@
+module Red
+  class DataNode # :nodoc:
+    attr_reader :value
+    
+    def initialize(value = nil)
+      @value = value
+    end
+    
+    def compile_node(options = {})
+      return @value.inspect
+    end
+    
+    def wrap_string(string, left_wrapper = "", right_wrapper = nil)
+      return "%s%s%s" % [left_wrapper, string, right_wrapper || left_wrapper]
+    end
+    
+    class ErrorNode < DataNode # :nodoc:
+      def compile_node(options = {})
+        "_____ Error %s _____" % [@value]
+      end
+      
+      def data_type
+        :error
+      end
+    end
+    
+    class NilNode < DataNode # :nodoc:
+      def compile_node(options = {})
+        ""
+      end
+    end
+    
+    class OtherNode < DataNode # :nodoc:
+    end
+    
+    class RangeNode < DataNode # :nodoc:
+      def initialize(*args)
+        case @@red_library
+          when :Prototype : super(*args)
+          else              raise(BuildError::NoRangeConstructor, "#{@@red_library} JavaScript library has no literal range constructor")
+        end
+      end
+      
+      def compile_node(options = {})
+        case @@red_library
+          when :Prototype : return "$R(%s, %s%s)" % self.compile_internals
+          else              return ""
+        end
+      end
+      
+      def compile_internals(options = {})
+        exclusive = @value.exclude_end? ? ", true" : ""
+        return [@value.begin, @value.end, exclusive]
+      end
+    end
+    
+    class StringNode < DataNode # :nodoc:
+      def compile_node(options = {})
+        options[:quotes] ||= "'"
+        return wrap_string(@value, options[:quotes])
+      end
+      
+      def data_type
+        :string
+      end
+    end
+    
+    class SymbolNode < DataNode # :nodoc:
+      def compile_node(options = {})
+        self.camelize!(options[:not_camelized])
+        return wrap_string(@value, options[:quotes])
+      end
+      
+      def camelize!(disabled = false)
+        return @value = @value.to_s unless camelize? && !disabled
+        words = @value.to_s.gsub(/@|\$/,'').split(/_| /)
+        underscore = words.shift if words.first.empty?
+        @value = (underscore ? '_' : '') + words[0] + words[1..-1].map {|word| word.capitalize}.join
+      end
+      
+      def camelize?
+        is_not_a_constant_name        = @value.to_s != @value.to_s.upcase
+        is_not_a_js_special_attribute = @value.to_s[0..1] != '__'
+        return is_not_a_constant_name && is_not_a_js_special_attribute
+      end
+      
+      def data_type
+        :symbol
+      end
+    end
+  end
+end

data/lib/red/definition_nodes.rb

@@ -0,0 +1,142 @@
+module Red
+  class DefinitionNode # :nodoc:
+    class ClassNode # :nodoc:
+      def initialize(class_name, superclass, scope)
+        raise(BuildError::NoClassInheritance, "Class inheritance is currently not supported#{"for the #{@@red_library} JavaScript library";''}") if superclass
+        old_class = @@red_class
+        @@red_class = @class = class_name
+        @class_name, @superclass = [class_name, superclass].build_nodes
+        block_node = scope.assoc(:block) || scope
+        if initializer_node = block_node.rassoc(:initialize)
+          args_node = initializer_node.assoc(:scope).assoc(:block).assoc(:args)
+          @arguments = (args_node[1..-1] || []).build_nodes
+          @initializer = initializer_node.assoc(:scope).assoc(:block).reject {|node| node == args_node}.build_node
+        end
+        properties = block_node.select {|node| (node.first == :cvdecl) rescue false }
+        functions = block_node.select {|node| (node != initializer_node) && ![:block, :scope].include?(node) }
+        @slots = (properties | functions).build_nodes
+        @@red_class = old_class
+      end
+      
+      def compile_node(options = {})
+        old_class = @@red_class
+        @@red_class = @class
+        if @initializer
+          output = self.compile_as_standard_class
+        else
+          output = self.compile_as_virtual_class
+        end
+        @@red_class = old_class
+        return output
+      end
+      
+      def compile_as_standard_class(options = {})
+        class_name = @class_name.compile_node
+        arguments = @arguments.compile_nodes.join(', ')
+        slots = @slots.compile_nodes(:as_attribute => true)
+        initializer = @initializer.compile_node
+        return "%s%s = function(%s) { %s;%s }" % [self.var?, class_name, arguments, initializer, slots]
+      end
+      
+      def compile_as_virtual_class(options = {})
+        class_name = @class_name.compile_node
+        slots = @slots.compile_nodes(:as_prototype => true).compact.join(', ')
+        return "%s%s = { %s }" % [self.var?, class_name, slots]
+      end
+      
+      def var?
+        return "var " unless @class_name.is_a?(LiteralNode::NamespaceNode)
+      end
+    end
+    
+    class ClassMethodNode # :nodoc:
+      def initialize(receiver, function_name, scope)
+        @receiver, @function_name = [receiver, function_name].build_nodes
+        @arguments = (scope.assoc(:block).assoc(:args)[1..-1] || []).build_nodes
+        @lines = (scope.assoc(:block)[2..-1] || []).build_nodes
+      end
+      
+      def compile_node(options = {})
+        case false
+        when options[:as_attribute].nil?
+          "this.%s = function(%s) { %s; }"
+        when options[:as_prototype].nil?
+          "%s: function(%s) { %s; }"
+        when !(options[:as_attribute].nil? && options[:as_prototype].nil?)
+          "function %s(%s) { %s; }"
+        end % self.compile_internals
+      end
+      
+      def compile_internals(options = {})
+        function_name = @function_name.compile_node
+        arguments = @arguments.compile_nodes.join(', ')
+        lines = @lines.compile_nodes.compact.join('; ')
+        return [function_name, arguments, lines]
+      end
+    end
+    
+    class InstanceMethodNode # :nodoc:
+      def initialize(function_name, scope)
+        block = scope.assoc(:block)
+        @@rescue_is_safe = (block[2].first == :rescue)
+        @function_name = (function_name == :function ? nil : function_name).build_node
+        @arguments = (block.assoc(:args)[1..-1] || []).build_nodes
+        @lines = (block[2..-1] || []).build_nodes
+      end
+      
+      def compile_node(options = {})
+        case false
+        when options[:as_attribute].nil?
+          "this.%s = function(%s) { %s; }"
+        when options[:as_prototype].nil?
+          "%s: function(%s) { %s; }"
+        when !(options[:as_attribute].nil? && options[:as_prototype].nil?)
+          "function %s(%s) { %s; }"
+        end % self.compile_internals
+      end
+      
+      def compile_internals(options = {})
+        function_name = @function_name.compile_node
+        arguments = @arguments.compile_nodes.join(', ')
+        lines = @lines.compile_nodes.compact.join('; ')
+        return [function_name, arguments, lines]
+      end
+    end
+    
+    class ModuleNode # :nodoc:
+      def initialize(module_name, scope)
+        old_module = @@red_module
+        @@red_module = module_name
+        @module_name, @scope = [module_name, scope].build_nodes
+        @@red_module = old_module
+      end
+      
+      def compile_node(options = {})
+        return "%s" % self.compile_internals
+      end
+      
+      def compile_internals(options = {})
+        old_module = @@red_module
+        @@red_module = @module_name.compile_node
+        scope = @scope.compile_node
+        @@red_module = old_module
+        return [scope]
+      end
+    end
+    
+      
+    class ObjectLiteralNode # :nodoc:
+      def initialize(receiver, scope)
+        block_node = scope.assoc(:block) || scope
+        properties = block_node.select {|node| (node.first == :cvdecl) rescue false }
+        functions = block_node.select {|node| ![:block, :scope].include?(node) }
+        @slots = (properties | functions).build_nodes
+      end
+      
+      def compile_node(options = {})
+        slots = @slots.compile_nodes(:as_prototype => true).compact.join(', ')
+        return "{ %s }" % [slots]
+      end
+    end
+  end
+end

data/lib/red/errors.rb

@@ -0,0 +1,95 @@
+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:
+    end
+    
+    # Raised when a flipflop operator is called using <tt>..</tt> or
+    # <tt>...</tt>
+    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
+  end
+end

data/lib/red/illegal_nodes.rb

@@ -0,0 +1,63 @@
+module Red
+  class IllegalNode # :nodoc:
+    class BlockArgument < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoBlockArguments, "JavaScript does not support block arguments")
+      end
+    end
+    
+    class FlipflopNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoFlipflops, "JavaScript does not support flip-flop operators")
+      end
+    end
+    
+    class MatchNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoArbitraryMatch, "JavaScript does not support arbitrary boolean matching")
+      end
+    end
+    
+    class MultipleAssignmentNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoMultipleAssignment, "JavaScript does not support catalogued assignment using multiple comma-separated expressions")
+      end
+    end
+    
+    class PostexeNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoBEGINorEND, "BEGIN and END blocks are not supported")
+      end
+    end
+    
+    class RedoNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoDoOvers, "JavaScript has no redo keyword")
+      end
+    end
+    
+    class RegexEvaluationNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoRegexEvaluation, "Construction of JavaScript regular expressions with evaluated content is not supported")
+      end
+    end
+    
+    class RetryNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoDoOvers, "JavaScript has no retry keyword")
+      end
+    end
+    
+    class SymbolEvaluationNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoSymbolEvaluation, "Construction of JavaScript identifiers through evaluated symbols is not supported")
+      end
+    end
+    
+    class UndefNode < IllegalNode # :nodoc:
+      def initialize(*args)
+        raise(BuildError::NoUndef, "JavaScript does not support undefinition of methods")
+      end
+    end
+  end
+end

data/lib/red/literal_nodes.rb

@@ -0,0 +1,119 @@
+module Red
+  class LiteralNode # :nodoc:
+    def initialize(*elements)
+      @initial    = elements.shift.build_node
+      @subsequent = elements.build_nodes
+    end
+    
+    def compile_node(options = {})
+      content = @initial.compile_node(options)
+      return "%s" % [content]
+    end
+    
+    def data_type
+      return :node unless @initial.is_a?(DataNode)
+      case @initial
+        when DataNode::NilNode    : :nil
+        when DataNode::RangeNode  : :range
+        when DataNode::StringNode : :string
+        when DataNode::SymbolNode : :symbol
+        else @initial.value.is_a?(Numeric) ? :numeric : :regexp
+      end
+    end
+    
+    class ArrayNode < LiteralNode # :nodoc:
+      def compile_node(options = {})
+        elements = @subsequent.unshift(@initial).compile_nodes.join(', ')
+        return "[%s]" % [elements]
+      end
+    end
+    
+    class HashNode < LiteralNode # :nodoc:
+      def initialize(*array)
+        @hash = {}
+        Hash[*array].each do |k,v|
+          key, value = [k,v].build_nodes
+          raise(BuildError::NoArbitraryHashKeys, "JavaScript does not support non-string objects as hash keys") unless [:string, :symbol].include?(key.data_type)
+          @hash[key] = value
+        end
+      end
+      
+      def compile_node(options = {})
+        pairs = @hash.map { |k,v| "%s: %s" % [k.compile_node(:quotes => "'"), v.compile_node(:as_argument => true)] }.join(', ')
+        "{ %s }" % [pairs]
+      end
+    end
+    
+    class MultilineNode < LiteralNode # :nodoc:
+      def compile_node(options = {})
+        lines = @subsequent.unshift(@initial).compile_nodes(options).compact.join('; ')
+        return "%s" % [lines]
+      end
+    end
+    
+    class NamespaceNode < LiteralNode # :nodoc:
+      def compile_node(options = {})
+        namespaces = @initial.compile_node
+        class_name = @subsequent.first.compile_node
+        return "%s.%s" % [namespaces, class_name]
+      end
+    end
+    
+    class OtherNode < LiteralNode # :nodoc:
+    end
+    
+    class RangeNode < LiteralNode # :nodoc:
+      def initialize(*args)
+        case @@red_library
+          when :Prototype : super(*args)
+          else              raise(BuildError::NoRangeConstructor, "#{@@red_library} JavaScript library has no literal range constructor")
+        end
+      end
+      
+      def compile_node(options = {})
+        start = @initial.compile_node(:as_argument => true)
+        finish = @subsequent.first.compile_node(:as_argument => true)
+        case @@red_library
+          when :Prototype : return "$R(%s, %s)" % [start, finish]
+          else              ""
+        end
+      end
+      
+      class ExclusiveNode < RangeNode # :nodoc:
+        def compile_node(options = {})
+          start = @initial.compile_node(:as_argument => true)
+          finish = @subsequent.first.compile_node(:as_argument => true)
+          case @@red_library
+            when :Prototype : return "$R(%s, %s, true)" % [start, finish]
+            else              ""
+          end
+        end
+      end
+    end
+    
+    class SplatNode < LiteralNode # :nodoc:
+      def initialize(*args)
+        case @@red_library
+          when :Prototype : super(*args)
+          else              raise(BuildError::NoSplatConstructor, "Splat array constructor not supported for #{@@red_library} JavaScript library")
+        end
+      end
+      
+      def compile_node(options = {})
+        initial = @initial.compile_node
+        case @@red_library
+          when :Prototype : return "$A(%s)" % [initial]
+          else              ""
+        end
+      end
+    end
+    
+    class StringNode < LiteralNode # :nodoc:
+      def compile_node(options = {})
+        initial    = @initial.compile_node(options)
+        subsequent = @subsequent.map {|element| " + %s" % [element.compile_node]}.join
+        return "%s%s" % [initial, subsequent]
+      end
+    end
+  end
+end

data/lib/red/variable_nodes.rb

@@ -0,0 +1,37 @@
+module Red
+  class VariableNode # :nodoc:
+    def initialize(variable_name)
+      @variable_name = variable_name.build_node
+    end
+    
+    def compile_node(options = {})
+      return "%s" % self.compile_internals
+    end
+    
+    def compile_internals(options = {})
+      return [@variable_name.compile_node]
+    end
+    
+    class ClassVariableNode < VariableNode # :nodoc:
+      def compile_node(options = {})
+        return "%s.%s" % self.compile_internals
+      end
+      
+      def compile_internals(options = {})
+        return [@@red_class, @variable_name.compile_node]
+      end
+    end
+    
+    class InstanceVariableNode < VariableNode # :nodoc:
+      def compile_node(options = {})
+        return "this.%s" % self.compile_internals
+      end
+    end
+    
+    class GlobalVariableNode < VariableNode # :nodoc:
+    end
+    
+    class OtherVariableNode < VariableNode # :nodoc:
+    end
+  end
+end

data/lib/red/version.rb

@@ -0,0 +1,9 @@
+module Red
+  module VERSION #:nodoc:
+    MAJOR = 3
+    MINOR = 0
+    TINY  = 0
+    
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/red/wrap_nodes.rb

@@ -0,0 +1,51 @@
+module Red
+  class WrapNode # :nodoc:
+    def initialize(expression = nil)
+      @expression = expression.build_node
+    end
+    
+    def compile_internals(options = {})
+      return [@expression].compile_nodes(:as_argument => true)
+    end
+    
+    class DefinedNode < WrapNode # :nodoc:
+      def compile_node(options = {})
+        return "typeof %s" % self.compile_internals
+      end
+    end
+    
+    class NotNode < WrapNode # :nodoc:
+      def compile_node(options = {})
+        return "!(%s)" % self.compile_internals
+      end
+    end
+    
+    class ReturnNode < WrapNode # :nodoc:
+      def compile_node(options = {})
+        return ("return %s" % self.compile_internals).rstrip
+      end
+    end
+    
+    class SuperNode < WrapNode # :nodoc:
+      def initialize(args = [nil])
+        case @@red_library
+          when :Prototype : @args = args[1..-1].build_nodes
+          else              raise(BuildError::NoSuperMethods, "Calls to super are not supported in #{@@red_library} JavaScript library")
+        end
+      end
+      
+      def compile_node(options = {})
+        case @@red_library
+          when :Prototype : return "$super(%s)" % @args.compile_nodes(:as_argument => true).join(', ')
+          else              return ""
+        end
+      end
+    end
+    
+    class YieldNode < WrapNode # :nodoc:
+      def compile_node(options = {})
+        return ("yield %s" % self.compile_internals).rstrip
+      end
+    end
+  end
+end