red 3.5.0 → 4.0.0

data/lib/red/nodes/variable_nodes.rb

@@ -0,0 +1,76 @@
+module Red
+  class VariableNode < String # :nodoc:
+    class ClassVariable < VariableNode # :nodoc:
+      # [:cvar, :@@foo]
+      def initialize(variable_name_sexp, options)
+        class_name = @@namespace_stack.join('.')
+        variable_name = variable_name_sexp.red!
+        self << "%s.cvget('%s')" % [class_name, variable_name]
+      end
+    end
+    
+    class Constant < VariableNode # :nodoc:
+      # ex.1: constant_name     = 'Baz'
+      #       @@namespace_stack = ['Foo', 'Bar']
+      #       @@red_constants   = ['Foo', 'Foo.Bar', 'Foo.Baz']
+      # 1st check: 'Foo.Bar.Baz' in @@red_constants
+      # 2nd check: 'Foo.Baz'     in @@red_constants
+      # finds it & returns 'Foo.Baz'
+      # 
+      # ex.2: constant_name     = 'Qux'
+      #       @@namespace_stack = ['Foo', 'Bar']
+      #       @@red_constants   = ['Foo', 'Foo.Bar', 'Foo.Baz']
+      # 1st check: 'Foo.Bar.Qux' in @@red_constants
+      # 2nd check: 'Foo.Qux'     in @@red_constants
+      # 3rd check: 'Qux'         in @@red_constants
+      # finds nothing & returns 'Foo.Bar.Qux'
+      
+      # [:const, :Foo]
+      def initialize(constant_name_sexp, options)
+        constant_name = "c$%s" % constant_name_sexp.red!
+        locally_namespaced_constant = (@@namespace_stack + [constant_name]).join('.')
+        i = -1
+        begin
+          constant = (@@namespace_stack[0..i] + [constant_name]).join('.')
+          preexisting_constant_namespace = constant if @@red_constants.include?(constant)
+          i -= 1
+        end until preexisting_constant_namespace || @@namespace_stack.size + i < -1
+        self << "%s" % [(preexisting_constant_namespace || locally_namespaced_constant)]
+      end
+    end
+    
+    class InstanceVariable < VariableNode # :nodoc:
+      # [:ivar, :@foo]
+      def initialize(variable_name_sexp, options)
+        variable_name = variable_name_sexp.red!
+        self << "this.i$%s" % [variable_name]
+      end
+    end
+    
+    class Keyword < VariableNode # :nodoc:
+      # [:nil]
+      # [:self]
+      def initialize(options)
+        string = case self when Nil : "nil" when Self : "this" end
+        self << string
+      end
+      
+      class Nil < Keyword # :nodoc:
+      end
+      
+      class Self < Keyword # :nodoc:
+      end
+    end
+    
+    class OtherVariable < VariableNode # :nodoc:
+      # [:dvar,  :foo]
+      # [:gvar,  :foo]
+      # [:lvar,  :foo]
+      # [:vcall, :foo]
+      def initialize(variable_name_sexp, options)
+        variable_name = variable_name_sexp.red!
+        self << "%s" % [variable_name]
+      end
+    end
+  end
+end

data/lib/red/plugin.rb

@@ -6,10 +6,11 @@ module Red
     
     def update_javascripts
       @@red_updated = true
+      Red.init
       red_dir = 'public/javascripts/red/'
-      Dir.glob("#{red_dir}**/*[.rb|.red]").each do |filepath|
-        if self.update_javascripts?(filename = filepath.gsub(red_dir,'').gsub(/.[rb|red]+$/,'')) || RAILS_ENV != 'production'
-          js_output = (File.read(filepath).string_to_node.compile_node || '') << (@@red_errors ||= '')
+      Dir.glob("#{red_dir}**/*.red").each do |filepath|
+        if self.update?(filename = filepath.gsub(red_dir,'').gsub(/.[rb|red]+$/,'')) || true
+          js_output = (File.read(filepath).translate_to_sexp_array.red! || '')
           
           filename.split('/')[0...-1].inject('public/javascripts') do |string,dir|
             new_dir = string << '/' << dir
@@ -18,13 +19,11 @@ module Red
           end
           
           File.open("public/javascripts/#{filename}.js", 'w') { |f| f.write(js_output) }
-          
-          @@red_errors = ''
         end
       end
     end
     
-    def update_javascripts?(filename)
+    def update?(filename)
       if File.exists?("public/javascripts/#{filename}.js")
         (File.mtime("public/javascripts/red/#{filename}.red") rescue File.mtime("public/javascripts/red/#{filename}.rb")) > File.mtime("public/javascripts/#{filename}.js")
       else
@@ -38,7 +37,7 @@ module Red
       base.send('alias_method', :red_old_process, :process)
       base.class_eval do
         def process(*args)
-          Red.update_javascripts unless Red.already_updated?
+          Red.update_javascripts #unless Red.already_updated?
           red_old_process(*args)
         end
       end

data/lib/red/version.rb

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

data/lib/red.rb

@@ -2,162 +2,240 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 require 'parse_tree'
-require 'red/assignment_nodes'
-require 'red/call_nodes'
-require 'red/conditional_nodes'
-require 'red/conjunction_nodes'
-require 'red/constant_nodes'
-require 'red/control_nodes'
-require 'red/data_nodes'
-require 'red/definition_nodes'
 require 'red/errors'
-require 'red/illegal_nodes'
-require 'red/literal_nodes'
 require 'red/plugin'
-require 'red/variable_nodes'
-require 'red/wrap_nodes'
+require 'red/nodes/assignment_nodes'
+require 'red/nodes/call_nodes'
+require 'red/nodes/control_nodes'
+require 'red/nodes/data_nodes'
+require 'red/nodes/definition_nodes'
+require 'red/nodes/illegal_nodes'
+require 'red/nodes/literal_nodes'
+require 'red/nodes/logic_nodes'
+require 'red/nodes/variable_nodes'
 
-module Red
-  @@red_library = nil
-  @@red_module  = nil
-  @@red_class   = :window
-  @@rescue_is_safe = false
-  @@exception_index = 0
-  
+module Red # :nodoc:
   ARRAY_NODES = {
-    :and          => ConjunctionNode::AndNode,
-    :argscat      => IllegalNode::MultipleAssignmentNode,
-    :argspush     => IllegalNode::MultipleAssignmentNode,
-    :array        => LiteralNode::ArrayNode,
-    :attrasgn     => AssignmentNode::AttributeNode,
-    :begin        => ControlNode::BeginNode,
-    :block        => LiteralNode::MultilineNode,
-    :block_arg    => IllegalNode::BlockArgument,
-    :block_pass   => IllegalNode::BlockArgument,
-    :break        => ConstantNode::BreakNode,
-    :call         => CallNode::MethodNode::ExplicitNode,
-    :case         => ConditionalNode::CaseNode,
-    :class        => DefinitionNode::ClassNode,
-    :cdecl        => AssignmentNode::GlobalVariableNode,
-    :colon2       => LiteralNode::NamespaceNode,
-    :colon3       => ControlNode::LibraryNode,
-    :const        => VariableNode::OtherVariableNode,
-    :cvar         => VariableNode::ClassVariableNode,
-    :cvasgn       => AssignmentNode::ClassVariableNode,
-    :cvdecl       => AssignmentNode::ClassVariableNode,
-    :dasgn        => AssignmentNode::LocalVariableNode,
-    :dasgn_curr   => AssignmentNode::LocalVariableNode,
-    :defined      => WrapNode::DefinedNode,
-    :defn         => DefinitionNode::InstanceMethodNode,
-    :defs         => DefinitionNode::ClassMethodNode,
-    :dot2         => LiteralNode::RangeNode,
-    :dot3         => LiteralNode::RangeNode::ExclusiveNode,
-    :dregx        => IllegalNode::RegexEvaluationNode,
+    :and          => LogicNode::Conjunction::And,
+    :alias        => DefinitionNode::Alias,
+    #:argscat      => IllegalNode::MultipleAssignmentNode,
+    #:argspush     => IllegalNode::MultipleAssignmentNode,
+    :array        => LiteralNode::Array,
+    :attrasgn     => AssignmentNode::Attribute,
+    :begin        => ControlNode::Begin,
+    :block        => LiteralNode::Multiline,
+    :block_arg    => CallNode::Block::Ampersand,
+    :block_pass   => CallNode::Ampersand,
+    :break        => ControlNode::Keyword::Break,
+    :call         => CallNode::Method::ExplicitReceiver,
+    :case         => LogicNode::Case,
+    :class        => DefinitionNode::Class,
+    :cdecl        => AssignmentNode::Constant,
+    :colon2       => LiteralNode::Namespace,
+    :colon3       => LiteralNode::Namespace::TopLevel,
+    :const        => VariableNode::Constant,
+    :cvar         => VariableNode::ClassVariable,
+    :cvasgn       => AssignmentNode::ClassVariable,
+    :cvdecl       => AssignmentNode::ClassVariable,
+    :dasgn        => AssignmentNode::LocalVariable,
+    :dasgn_curr   => AssignmentNode::LocalVariable,
+    :defined      => CallNode::Defined,
+    :defn         => DefinitionNode::Method::Instance,
+    :defs         => DefinitionNode::Method::Singleton,
+    :dot2         => LiteralNode::Range,
+    :dot3         => LiteralNode::Range::Exclusive,
+    :dregx        => LiteralNode::Regexp,
     :dregx_once   => IllegalNode::RegexEvaluationNode,
-    :dstr         => LiteralNode::StringNode,
-    :dsym         => IllegalNode::SymbolEvaluationNode,
-    :dvar         => VariableNode::OtherVariableNode,
-    :dxstr        => LiteralNode::StringNode,
-    :ensure       => ControlNode::EnsureNode,
-    :evstr        => LiteralNode::StringNode,
-    :false        => ConstantNode::FalseNode,
-    :fcall        => CallNode::MethodNode::ImplicitNode,
+    :dstr         => LiteralNode::String,
+    :dsym         => LiteralNode::Symbol,
+    :dvar         => VariableNode::OtherVariable,
+    :dxstr        => LiteralNode::Uninterpreted,
+    :ensure       => ControlNode::Ensure,
+    :evstr        => LiteralNode::String,
+    :false        => LogicNode::Boolean::False,
+    :fcall        => CallNode::Method::ImplicitReceiver,
     :flip2        => IllegalNode::FlipflopNode,
     :flip3        => IllegalNode::FlipflopNode,
-    :for          => ControlNode::ForNode,
-    :gasgn        => AssignmentNode::GlobalVariableNode,
-    :gvar         => VariableNode::GlobalVariableNode,
-    :hash         => LiteralNode::HashNode,
-    :iasgn        => AssignmentNode::InstanceVariableNode,
-    :if           => ConditionalNode::IfNode,
-    :iter         => CallNode::BlockNode,
-    :ivar         => VariableNode::InstanceVariableNode,
-    :lasgn        => AssignmentNode::LocalVariableNode,
-    :lvar         => VariableNode::OtherVariableNode,
-    :lit          => LiteralNode::OtherNode,
+    :for          => ControlNode::For,
+    :gasgn        => AssignmentNode::GlobalVariable,
+    :gvar         => VariableNode::OtherVariable,
+    :hash         => LiteralNode::Hash,
+    :iasgn        => AssignmentNode::InstanceVariable,
+    :if           => LogicNode::If,
+    :iter         => CallNode::Block,
+    :ivar         => VariableNode::InstanceVariable,
+    :lasgn        => AssignmentNode::LocalVariable,
+    :lvar         => VariableNode::OtherVariable,
+    :lit          => LiteralNode::Other,
     :match        => IllegalNode::MatchNode,
-    :match2       => CallNode::MatchNode,
-    :match3       => CallNode::MatchNode::ReverseNode,
-    :masgn        => IllegalNode::MultipleAssignmentNode,
-    :module       => DefinitionNode::ModuleNode,
-    :next         => ConstantNode::NextNode,
-    :nil          => ConstantNode::NilNode,
-    :not          => WrapNode::NotNode,
-    :op_asgn1     => AssignmentNode::OperatorNode::BracketNode,
-    :op_asgn2     => AssignmentNode::OperatorNode::DotNode,
-    :op_asgn_and  => AssignmentNode::OperatorNode::AndNode,
-    :op_asgn_or   => AssignmentNode::OperatorNode::OrNode,
-    :or           => ConjunctionNode::OrNode,
+    :match2       => CallNode::Match,
+    :match3       => CallNode::Match::Reverse,
+    :masgn        => AssignmentNode::Multiple,
+    :module       => DefinitionNode::Module,
+    :next         => ControlNode::Keyword::Next,
+    :nil          => VariableNode::Keyword::Nil,
+    :not          => LogicNode::Not,
+    :op_asgn1     => AssignmentNode::Operator::Bracket,
+    :op_asgn2     => AssignmentNode::Operator::Dot,
+    :op_asgn_and  => AssignmentNode::Operator::And,
+    :op_asgn_or   => AssignmentNode::Operator::Or,
+    :or           => LogicNode::Conjunction::Or,
     :postexe      => IllegalNode::PostexeNode,
-    :redo         => IllegalNode::RedoNode,
-    :rescue       => ControlNode::RescueNode,
+    :redo         => ControlNode::Keyword::Redo,
+    :regex        => LiteralNode::Regexp,
+    :resbody      => ControlNode::RescueBody,
+    :rescue       => ControlNode::Rescue,
     :retry        => IllegalNode::RetryNode,
-    :return       => WrapNode::ReturnNode,
-    :sclass       => DefinitionNode::ObjectLiteralNode,
-    :scope        => LiteralNode::OtherNode,
-    :self         => ConstantNode::SelfNode,
-    :splat        => LiteralNode::SplatNode,
-    :super        => WrapNode::SuperNode,
-    :svalue       => LiteralNode::OtherNode,
-    :str          => LiteralNode::StringNode,
-    :true         => ConstantNode::TrueNode,
-    :undef        => IllegalNode::UndefNode,
-    :until        => ControlNode::UntilNode,
-    :vcall        => VariableNode::OtherVariableNode,
-    :when         => ConditionalNode::WhenNode,
-    :while        => ControlNode::WhileNode,
-    :xstr         => LiteralNode::StringNode,
-    :yield        => WrapNode::YieldNode,
-    :zarray       => LiteralNode::ArrayNode,
-    :zsuper       => WrapNode::SuperNode
+    :return       => ControlNode::Return,
+    :sclass       => DefinitionNode::SingletonClass,
+    :scope        => DefinitionNode::Scope,
+    :self         => VariableNode::Keyword::Self,
+    :splat        => LiteralNode::Splat,
+    :super        => CallNode::Super,
+    :svalue       => LiteralNode::Other,
+    :str          => LiteralNode::String,
+    :sym          => LiteralNode::Symbol,
+    :to_ary       => LiteralNode::Array,
+    :true         => LogicNode::Boolean::True,
+    :undef        => DefinitionNode::Undef,
+    :until        => ControlNode::Loop::Until,
+    :vcall        => VariableNode::OtherVariable,
+    :when         => LogicNode::Case::When,
+    :while        => ControlNode::Loop::While,
+    :xstr         => LiteralNode::Uninterpreted,
+    :yield        => CallNode::Yield,
+    :zarray       => LiteralNode::Array,
+    :zsuper       => CallNode::Super::Delegate
   }
   
   DATA_NODES = {
-    Bignum        => DataNode::OtherNode,
-    Fixnum        => DataNode::OtherNode,
-    Float         => DataNode::OtherNode,
-    Range         => DataNode::RangeNode,
-    Regexp        => DataNode::OtherNode,
-    Symbol        => DataNode::SymbolNode,
-    String        => DataNode::StringNode,
-    NilClass      => DataNode::NilNode
+    Bignum        => DataNode::Numeric,
+    Fixnum        => DataNode::Numeric,
+    Float         => DataNode::Numeric,
+    Range         => DataNode::Range,
+    Regexp        => DataNode::Regexp,
+    Symbol        => DataNode::Symbol,
+    String        => DataNode::String,
+    NilClass      => DataNode::Nil
+  }
+  
+  METHOD_ESCAPE = {
+    :==           => :_eql2,
+    :===          => :_eql3,
+    :=~           => :_etld,
+    :[]           => :_brac,
+    :[]=          => :_breq,
+    :<=           => :_lteq,
+    :>=           => :_gteq,
+    :<<           => :_ltlt,
+    :>>           => :_gtgt,
+    :<            => :_lthn,
+    :>            => :_gthn,
+    :'<=>'        => :_ltgt,
+    :|            => :_pipe,
+    :&            => :_ampe,
+    :+            => :_plus,
+    :+@           => :_posi,
+    :-            => :_subt,
+    :-@           => :_nega,
+    :*            => :_star,
+    :**           => :_str2,
+    :/            => :_slsh,
+    :%            => :_perc,
+    :'^'          => :_care,
+    :~            => :_tild
   }
   
-  def build_node # :nodoc:
+  NATIVE_CONSTANTS = %w{
+    c$Object
+    c$Module
+    c$Class
+    c$Comparable
+    c$Enumerable
+    c$Kernel
+    c$Math
+    c$Math.c$E
+    c$Math.c$PI
+    c$Array
+    c$Exception
+    c$StandardError
+    c$ArgumentError
+    c$IndexError
+    c$RangeError
+    c$RuntimeError
+    c$TypeError
+    c$FalseClass
+    c$Hash
+    c$MatchData
+    c$NilClass
+    c$Numeric
+    c$Proc
+    c$Range
+    c$Regexp
+    c$Regexp.c$IGNORECASE
+    c$Regexp.c$EXTENDED
+    c$Regexp.c$MULTILINE
+    c$String
+    c$Symbol
+    c$Time
+    c$TrueClass
+  }
+  
+  INTERNAL_METHODS = %w{
+    []
+    <=>
+    ==
+    allocate
+    append_features
+    backtrace
+    block_given?
+    call
+    class
+    extend_object
+    extended
+    hash
+    include
+    included
+    inherited
+    initialize
+    inspect
+    is_a?
+    join
+    new
+    sprintf
+    to_proc
+    to_s
+    to_str
+  }.map {|m| m.to_sym }
+  
+  def self.init
+    @@namespace_stack = []
+    @@red_constants   = NATIVE_CONSTANTS
+    @@red_methods     = INTERNAL_METHODS
+    @@red_function    = nil
+    @@red_block_arg   = nil
+    @@red_import      = false
+    return true
+  end
+  
+  def red!(options = {}, reset = false)
+    Red.init if reset
     case self
     when Array
       raise(BuildError::UnknownNode, "Don't know how to handle sexp type :#{self.first}") unless ARRAY_NODES[self.first]
-      return ARRAY_NODES[self.first].new(*self[1..-1])
+      return ARRAY_NODES[self.first].new(*(self[1..-1] + [options]))
     else
-      return DATA_NODES[self.class].new(self)
+      return DATA_NODES[self.class].new(self, options)
     end
-  rescue => e
-    self.handle_red_error(e)
-  end
-  
-  def build_nodes  # :nodoc:
-    self.map {|node| node.build_node}
-  end
-  
-  def compile_nodes(options = {}) # :nodoc:
-    self.map {|node| node.compile_node(options)}
-  end
-  
-  def string_to_node # :nodoc:
-    self.translate_to_sexp_array.build_node
-  rescue SyntaxError => e
-    self.handle_red_error(e)
   end
   
-  def translate_to_sexp_array # :nodoc:
+  def translate_to_sexp_array
     raise TypeError, "Can only translate Strings" unless self.is_a?(String)
-    ParseTree.translate("::Standard\n" + self)
+    ParseTree.translate(self)
   end
   
-  def handle_red_error(error) # :nodoc:
-    @@red_errors ||= "\n// Errors"
-    @@red_errors << "\n// %s: %s" % [@@exception_index += 1, error]
-    return DataNode::ErrorNode.new(@@exception_index)
+  def is_sexp?(*sexp_types)
+    self.is_a?(Array) && sexp_types.include?(self.first)
   end
   
   def self.rails