red 3.5.0 → 4.0.0

data/lib/red/constant_nodes.rb

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

@@ -1,129 +0,0 @@
-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 = @condition.compile_node(:skip_var => true)
-        body = @body.compile_node
-        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 = @condition.compile_node(:skip_var => true)
-        body = @body.compile_node
-        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

data/lib/red/data_nodes.rb

@@ -1,93 +0,0 @@
-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 == word.upcase ? word : word.capitalize }.join
-      end
-      
-      def camelize?
-        value = @value.to_s
-        is_not_a_constant_name        = value != value.upcase || value =~ (/@|\$/)
-        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

@@ -1,177 +0,0 @@
-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
-        case @@red_library
-        when :Prototype
-          @initializer = block_node.rassoc(:initialize)
-          @classes = block_node.select {|node| (node.first == :class) rescue false }.build_nodes
-          @properties = block_node.select {|node| (node.first == :cvdecl) rescue false }.build_nodes
-          @functions = block_node.select {|node| ![:block, :scope].include?(node) && ((node.first != :cvdecl) rescue false) }.build_nodes
-        else
-          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
-          @classes = block_node.select {|node| (node.first == :class) rescue false }.build_nodes
-          @properties = block_node.select {|node| (node.first == :cvdecl) rescue false }.build_nodes
-          @functions = block_node.select {|node| (node != initializer_node) && ![:block, :scope].include?(node) && ((node.first != :cvdecl) rescue false) }.build_nodes
-        end
-        @@red_class = old_class
-      end
-      
-      def compile_node(options = {})
-        old_class = @@red_class
-        @@red_class = @class
-        if options[:as_prototype]
-          output = self.compile_as_child_class
-        elsif @initializer
-          case @@red_library
-          when :Prototype
-            output = self.compile_as_prototype_class
-          else
-            output = self.compile_as_standard_class
-          end
-        else
-          output = self.compile_as_virtual_class
-        end
-        @@red_class = old_class
-        return output
-      end
-      
-      def compile_as_child_class
-        class_name = @class_name.compile_node
-        slots = (@classes | @properties | @functions).compile_nodes(:as_prototype => true).compact.join(', ')
-        return "%s: { %s }" % [class_name, slots]
-      end
-      
-      def compile_as_prototype_class
-        class_name = @class_name.compile_node
-        functions = @functions.compile_nodes(:as_prototype => true).compact.join(', ')
-        properties = @properties.compile_nodes(:as_prototype => true).compact.join(', ')
-        return "%s%s = Class.create({ %s });Object.extend(%s, { %s })" % [self.var?, class_name, functions, class_name, properties]
-      end
-      
-      def compile_as_standard_class(options = {})
-        class_name = @class_name.compile_node
-        arguments = @arguments.compile_nodes.join(', ')
-        initializer = @initializer.compile_node
-        functions = @functions.compile_nodes(:as_attribute => true).join('; ')
-        properties = @properties.compile_nodes.join('; ')
-        return "%s%s = function(%s) { %s;%s }; %s" % [self.var?, class_name, arguments, initializer, functions, properties]
-      end
-      
-      def compile_as_virtual_class(options = {})
-        class_name = @class_name.compile_node
-        slots = (@properties | @functions).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)
-        old_class = @@red_class
-        @@red_class = @class = receiver.build_node.compile_node
-        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
-        @@red_class = old_class
-      end
-      
-      def compile_node(options = {})
-        old_class = @@red_class
-        @@red_class = @class
-        slots = @slots.compile_nodes(:as_prototype => true).compact.join(', ')
-        @@red_class = old_class
-        return "{ %s }" % [slots]
-      end
-    end
-  end
-end

data/lib/red/illegal_nodes.rb

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

@@ -1,119 +0,0 @@
-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 : (@subsequent.empty? ? :string : :eval)
-        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.reject {|element| element.empty? }.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

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