opal 0.6.3 → 0.7.0.beta1

data/lib/opal/erb.rb

@@ -3,29 +3,42 @@ require 'opal/compiler'
 module Opal
   module ERB
     def self.compile(source, file_name = '(erb)')
-      Compiler.new.compile source, file_name
+      Compiler.new(source, file_name).compile
     end
 
     class Compiler
-      def compile(source, file_name = '(erb)')
+      def initialize(source, file_name = '(erb)')
         @source, @file_name, @result = source, file_name, source
+      end
 
-        self.fix_quotes
-        self.find_contents
-        self.find_code
-        self.wrap_compiled
+      def prepared_source
+        @prepared_source ||= begin
+          source = @source
+          source = fix_quotes(source)
+          source = find_contents(source)
+          source = find_code(source)
+          source = wrap_compiled(source)
+          source = require_erb(source)
+          source
+        end
+      end
 
-        Opal.compile @result
+      def compile
+        Opal.compile prepared_source
       end
 
-      def fix_quotes
-        @result = @result.gsub '"', '\\"'
+      def fix_quotes(result)
+        result.gsub '"', '\\"'
       end
 
       BLOCK_EXPR = /\s+(do|\{)(\s*\|[^|]*\|)?\s*\Z/
 
-      def find_contents
-        @result = @result.gsub(/<%=([\s\S]+?)%>/) do
+      def require_erb(result)
+        'require "erb";'+result
+      end
+
+      def find_contents(result)
+        result.gsub(/<%=([\s\S]+?)%>/) do
           inner = $1.gsub(/\\'/, "'").gsub(/\\"/, '"')
 
           if inner =~ BLOCK_EXPR
@@ -36,14 +49,15 @@ module Opal
         end
       end
 
-      def find_code
-        @result = @result.gsub(/<%([\s\S]+?)%>/) do
+      def find_code(result)
+        result.gsub(/<%([\s\S]+?)%>/) do
           "\")\n#{ $1 }\noutput_buffer.append(\""
         end
       end
 
-      def wrap_compiled
-        @result = "Template.new('#@file_name') do |output_buffer|\noutput_buffer.append(\"#@result\")\noutput_buffer.join\nend\n"
+      def wrap_compiled(result)
+        path = @file_name.sub(/\.opalerb$/, '')
+        result = "Template.new('#{path}') do |output_buffer|\noutput_buffer.append(\"#{result}\")\noutput_buffer.join\nend\n"
       end
     end
   end

data/lib/opal/hike_path_finder.rb

@@ -0,0 +1,18 @@
+require 'hike'
+require 'pathname'
+
+module Opal
+  class HikePathFinder < Hike::Trail
+    def initialize(paths = Opal.paths)
+      super()
+      append_paths(*paths)
+      append_extensions '.js', '.js.rb', '.rb', '.opalerb'
+    end
+
+    def find path
+      pathname = Pathname(path)
+      return path if pathname.absolute? and pathname.exist?
+      super
+    end
+  end
+end

data/lib/opal/nodes.rb

@@ -18,6 +18,7 @@ require 'opal/nodes/case'
 require 'opal/nodes/super'
 require 'opal/nodes/top'
 require 'opal/nodes/while'
+require 'opal/nodes/for'
 require 'opal/nodes/hash'
 require 'opal/nodes/array'
 require 'opal/nodes/defined'

data/lib/opal/nodes/call.rb

@@ -9,22 +9,34 @@ module Opal
 
       children :recvr, :meth, :arglist, :iter
 
-      SPECIALS = Set.new
+      SPECIALS = {}
 
-      def self.add_special(name, &handler)
-        SPECIALS << name
+      # Operators that get optimized by compiler
+      OPERATORS = { :+ => :plus, :- => :minus, :* => :times, :/ => :divide,
+                    :< => :lt, :<= => :le, :> => :gt, :>= => :ge }
+
+      def self.add_special(name, options = {}, &handler)
+        SPECIALS[name] = options
         define_method("handle_#{name}", &handler)
       end
 
       def compile
-        # if we handle this call specially, just do that and return early
-        return if self.handle_special
+        # handle some methods specially
+        handle_special
+
+        # some special methods need to skip compilation
+        return unless compile_default?
 
         compiler.method_calls << meth.to_sym
 
         # if trying to access an lvar in irb mode
         return compile_irb_var if using_irb?
 
+        default_compile
+      end
+
+      def default_compile
+
         mid = mid_to_jsid meth.to_s
 
         splat = arglist[1..-1].any? { |a| a.first == :splat }
@@ -35,8 +47,8 @@ module Opal
           block = iter
         end
 
-        tmpfunc = scope.new_temp if block
-        tmprecv = scope.new_temp if splat || tmpfunc
+        blktmp  = scope.new_temp if block
+        tmprecv = scope.new_temp if splat || blktmp
 
         # must do this after assigning temp variables
         block = expr(block) if block
@@ -44,7 +56,7 @@ module Opal
         recv_code = recv(recv_sexp)
         call_recv = s(:js_tmp, tmprecv || recv_code)
 
-        if tmpfunc and !splat
+        if blktmp and !splat
           arglist.insert 1, call_recv
         end
 
@@ -56,26 +68,30 @@ module Opal
           push recv_code, mid
         end
 
-        if tmpfunc
-          unshift "(#{tmpfunc} = "
-          push ", #{tmpfunc}._p = ", block, ", #{tmpfunc})"
+        if blktmp
+          unshift "(#{blktmp} = "
+          push ", #{blktmp}.$$p = ", block, ", #{blktmp})"
         end
 
         if splat
           push ".apply(", (tmprecv || recv_code), ", ", args, ")"
-        elsif tmpfunc
+        elsif blktmp
           push ".call(", args, ")"
         else
           push "(", args, ")"
         end
 
-        scope.queue_temp tmpfunc if tmpfunc
+        scope.queue_temp blktmp if blktmp
       end
 
       def recv_sexp
         recvr || s(:self)
       end
 
+      def attr_assignment?
+        @assignment ||= meth.to_s =~ /^[\da-z]+\=$/i
+      end
+
       # Used to generate the code to use this sexp as an ivar var reference
       def compile_irb_var
         with_temp do |tmp|
@@ -85,6 +101,19 @@ module Opal
         end
       end
 
+      def compile_assignment
+        with_temp do |args_tmp|
+          with_temp do |recv_tmp|
+            args = expr(arglist)
+            mid = mid_to_jsid meth.to_s
+            push "((#{args_tmp} = [", args, "]), "+
+                 "#{recv_tmp} = ", recv(recv_sexp), ", ",
+                 recv_tmp, mid, ".apply(#{recv_tmp}, #{args_tmp}), "+
+                 "#{args_tmp}[#{args_tmp}.length-1])"
+          end
+        end
+      end
+
       # a variable reference in irb mode in top scope might be a var ref,
       # or it might be a method call
       def using_irb?
@@ -95,53 +124,105 @@ module Opal
       # this method. If this method returns nil, then the method will continue
       # to be generated by CallNode.
       def handle_special
+        @compile_default = true
+
         if SPECIALS.include? meth
-          if result = __send__("handle_#{meth}")
-            push result
-            return true
-          end
+          @compile_default = false
+          __send__("handle_#{meth}")
         elsif RuntimeHelpers.compatible?(recvr, meth, arglist)
+          @compile_default = false
           push(RuntimeHelpers.new(@sexp, @level, @compiler).compile)
-          return true
+        end
+      end
+
+      def compile_default!
+        @compile_default = true
+      end
+
+      def compile_default?
+        @compile_default
+      end
+
+      OPERATORS.each do |operator, name|
+        add_special(operator.to_sym) do
+          if compiler.inline_operators?
+            compiler.operator_helpers << operator.to_sym
+            lhs, rhs = expr(recvr), expr(arglist[1])
+
+            push fragment("$rb_#{name}(")
+            push lhs
+            push fragment(", ")
+            push rhs
+            push fragment(")")
+          else
+            compile_default!
+          end
         end
       end
 
       add_special :require do
+        compile_default!
         str = DependencyResolver.new(compiler, arglist[1]).resolve
         compiler.requires << str unless str.nil?
-        stmt? ? fragment('') : fragment('true')
+        push fragment('')
+      end
+
+      add_special :require_relative do
+        arg = arglist[1]
+        file = compiler.file
+        if arg[0] == :str
+          dir = File.dirname(file)
+          compiler.requires << File.expand_path(arg[1], dir)
+        end
+        push fragment("self.$require(#{file.inspect}+ '/../' + ")
+        push process(arglist)
+        push fragment(')')
       end
 
       add_special :autoload do
         if scope.class_scope?
+          compile_default!
           str = DependencyResolver.new(compiler, arglist[2]).resolve
           compiler.requires << str unless str.nil?
-          fragment ''
+          push fragment('')
+        end
+      end
+
+      add_special :require_tree do
+        arg = arglist[1]
+        if arg[0] == :str
+          dir = File.dirname(compiler.file)
+          relative_path = arg[1]
+          full_path = Pathname(dir).join(relative_path).cleanpath.to_s
+          compiler.required_trees << full_path
+          arg[1] = full_path
         end
+        compile_default!
+        push fragment('')
       end
 
       add_special :block_given? do
-        compiler.handle_block_given_call @sexp
+        push compiler.handle_block_given_call @sexp
       end
 
       add_special :__callee__ do
         if scope.def?
-          fragment scope.mid.to_s.inspect
+          push fragment scope.mid.to_s.inspect
         else
-          fragment 'nil'
+          push fragment 'nil'
         end
       end
 
       add_special :__method__ do
         if scope.def?
-          fragment scope.mid.to_s.inspect
+          push fragment scope.mid.to_s.inspect
         else
-          fragment 'nil'
+          push fragment 'nil'
         end
       end
 
       add_special :debugger do
-        fragment 'debugger'
+        push fragment 'debugger'
       end
 
       class DependencyResolver

data/lib/opal/nodes/call_special.rb

@@ -1,17 +1,29 @@
 require 'opal/nodes/base'
+require 'opal/nodes/call'
 
 module Opal
   module Nodes
     # recv.mid = rhs
     # s(:recv, :mid=, s(:arglist, rhs))
-    class AttrAssignNode < Base
+    class AttrAssignNode < CallNode
       handle :attrasgn
 
-      children :recvr, :mid, :arglist
+      children :recvr, :meth, :arglist
 
-      def compile
-        sexp = s(:call, recvr, mid, arglist)
-        push process(sexp, @level)
+      def default_compile
+        # Skip, for now, if the method has square brackets: []=
+        return super if meth.to_s !~ /^\w+=$/
+
+        with_temp do |args_tmp|
+          with_temp do |recv_tmp|
+            args = expr(arglist)
+            mid = mid_to_jsid meth.to_s
+            push "((#{args_tmp} = [", args, "]), "+
+                 "#{recv_tmp} = ", recv(recv_sexp), ", ",
+                 recv_tmp, mid, ".apply(#{recv_tmp}, #{args_tmp}), "+
+                 "#{args_tmp}[#{args_tmp}.length-1])"
+          end
+        end
       end
     end
 
@@ -39,7 +51,7 @@ module Opal
         sexp = s(:or, recvr, rhs)
         push expr(sexp)
       end
-    end 
+    end
 
     # a &&= rhs
     # s(:op_asgn_and, s(:lvar, :a), s(:lasgn, a:, rhs))
@@ -98,6 +110,19 @@ module Opal
           end
         end
       end
+
+      def compile_and
+        with_temp do |a| # args
+          with_temp do |r| # recv
+            aref = s(:call, s(:js_tmp, r), :[], s(:arglist, s(:js_tmp, a)))
+            aset = s(:call, s(:js_tmp, r), :[]=, s(:arglist, s(:js_tmp, a), rhs))
+            andop = s(:and, aref, aset)
+
+            push "(#{a} = ", expr(first_arg), ", #{r} = ", expr(lhs)
+            push ", ", expr(andop), ")"
+          end
+        end
+      end
     end
 
     # lhs.b += rhs

data/lib/opal/nodes/class.rb

@@ -17,8 +17,8 @@ module Opal
 
         in_scope do
           scope.name = name
-          add_temp "#{scope.proto} = self._proto"
-          add_temp "$scope = self._scope"
+          add_temp "#{scope.proto} = self.$$proto"
+          add_temp "$scope = self.$$scope"
 
           body_code = self.body_code
           empty_line

data/lib/opal/nodes/constants.rb

@@ -10,12 +10,8 @@ module Opal
       def compile
         if name == :DATA and compiler.eof_content
           push("$__END__")
-        elsif compiler.const_missing?
-          with_temp do |tmp|
-            push "((#{tmp} = $scope.#{name}) == null ? $opal.cm('#{name}') : #{tmp})"
-          end
         else
-          push "$scope.#{name}"
+          push "$scope.get('#{name}')"
         end
       end
     end
@@ -51,17 +47,9 @@ module Opal
       children :base, :name
 
       def compile
-        if compiler.const_missing?
-          with_temp do |tmp|
-            push "((#{tmp} = ("
-            push expr(base)
-            push ")._scope).#{name} == null ? #{tmp}.cm('#{name}') : "
-            push "#{tmp}.#{name})"
-          end
-        else
-          push expr(base)
-          wrap '(', ")._scope.#{name}"
-        end
+        push "(("
+        push expr(base)
+        push ").$$scope.get('#{name}'))"
       end
     end
 
@@ -71,10 +59,7 @@ module Opal
       children :name
 
       def compile
-        with_temp do |tmp|
-          push "((#{tmp} = $opal.Object._scope.#{name}) == null ? "
-          push "$opal.cm('#{name}') : #{tmp})"
-        end
+        push "Opal.get('#{name}')"
       end
     end