opal 0.10.0 → 0.11.0

data/lib/opal/path_reader.rb

@@ -1,9 +1,16 @@
-require 'opal/hike_path_finder'
+# frozen_string_literal: true
+require 'opal/regexp_anchors'
+require 'hike'
 
 module Opal
   class PathReader
-    def initialize(file_finder = HikePathFinder.new)
-      @file_finder = file_finder
+    RELATIVE_PATH_REGEXP = %r{#{Opal::REGEXP_START}\.?\.#{Regexp.quote File::SEPARATOR}}
+    DEFAULT_EXTENSIONS = ['.js', '.js.rb', '.rb', '.opalerb']
+
+    def initialize(paths = Opal.paths, extensions = DEFAULT_EXTENSIONS)
+      @file_finder = Hike::Trail.new
+      @file_finder.append_paths(*paths)
+      @file_finder.append_extensions(*extensions)
     end
 
     def read(path)
@@ -13,10 +20,10 @@ module Opal
     end
 
     def expand(path)
-      if Pathname.new(path).absolute? || path =~ %r{\A\.?\.#{File::SEPARATOR}}
+      if Pathname.new(path).absolute? || path =~ RELATIVE_PATH_REGEXP
         path
       else
-        file_finder.find(path)
+        find_path(path)
       end
     end
 
@@ -24,12 +31,22 @@ module Opal
       file_finder.paths
     end
 
+    def extensions
+      file_finder.extensions
+    end
+
     def append_paths(*paths)
       file_finder.append_paths(*paths)
     end
 
     private
 
+    def find_path(path)
+      pathname = Pathname(path)
+      return path if pathname.absolute? and pathname.exist?
+      file_finder.find(path)
+    end
+
     attr_reader :file_finder
   end
 end

data/lib/opal/paths.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
 module Opal
   def self.gem_dir
-    File.expand_path('../..', __FILE__.untaint)
+    File.expand_path("../..", __FILE__.dup.untaint)
   end
 
   def self.core_dir
-    File.expand_path('../../../opal', __FILE__.untaint)
+    File.expand_path("../../../opal", __FILE__.dup.untaint)
   end
 
   def self.std_dir
-    File.expand_path('../../../stdlib', __FILE__.untaint)
+    File.expand_path("../../../stdlib", __FILE__.dup.untaint)
   end
 
   # Add a file path to opals load path. Any gem containing ruby code that Opal
@@ -66,9 +67,14 @@ module Opal
     @paths.dup.freeze
   end
 
-  # Resets Opal.paths to the default value (includes `corelib`, `stdlib`, `opal/lib`)
+  # Resets Opal.paths to the default value
+  # (includes `corelib`, `stdlib`, `opal/lib`, `ast` gem and `parser` gem)
   def self.reset_paths!
     @paths = [core_dir.untaint, std_dir.untaint, gem_dir.untaint]
+    if RUBY_ENGINE != 'opal'
+      use_gem 'ast'
+      use_gem 'parser'
+    end
     nil
   end
 

data/lib/opal/regexp_anchors.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Opal
   REGEXP_START = RUBY_ENGINE == 'opal' ? '^' : '\A'.freeze
   REGEXP_END = RUBY_ENGINE == 'opal' ? '$' : '\z'.freeze

data/lib/opal/rewriter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require 'opal/rewriters/opal_engine_check'
+require 'opal/rewriters/for_rewriter'
+require 'opal/rewriters/explicit_writer_return'
+require 'opal/rewriters/js_reserved_words'
+require 'opal/rewriters/block_to_iter'
+require 'opal/rewriters/dot_js_syntax'
+require 'opal/rewriters/logical_operator_assignment'
+require 'opal/rewriters/binary_operator_assignment'
+require 'opal/rewriters/hashes/key_duplicates_rewriter'
+
+module Opal
+  class Rewriter
+    class << self
+      def list
+        @list ||= []
+      end
+
+      def use(rewriter)
+        list << rewriter
+      end
+
+      def delete(rewriter)
+        list.delete(rewriter)
+      end
+
+      def disable
+        @disabled = true
+        yield
+      ensure
+        @disabled = false
+      end
+
+      def disabled?
+        @disabled if defined?(@disabled)
+      end
+    end
+
+    use Rewriters::OpalEngineCheck
+    use Rewriters::ForRewriter
+    use Rewriters::BlockToIter
+    use Rewriters::DotJsSyntax
+    use Rewriters::JsReservedWords
+    use Rewriters::LogicalOperatorAssignment
+    use Rewriters::BinaryOperatorAssignment
+    use Rewriters::ExplicitWriterReturn
+    use Rewriters::Hashes::KeyDuplicatesRewriter
+
+    def initialize(sexp)
+      @sexp = sexp
+    end
+
+    def process
+      return @sexp if self.class.disabled?
+
+      self.class.list.each do |rewriter_class|
+        rewriter = rewriter_class.new
+        @sexp = rewriter.process(@sexp)
+      end
+
+      @sexp
+    end
+  end
+end

data/lib/opal/rewriters/base.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+require 'parser'
+require 'opal/ast/node'
+
+module Opal
+  module Rewriters
+    class Base < ::Parser::AST::Processor
+      def s(type, *children)
+        ::Opal::AST::Node.new(type, children)
+      end
+
+      def self.s(type, *children)
+        ::Opal::AST::Node.new(type, children)
+      end
+
+      alias on_iter       process_regular_node
+      alias on_top        process_regular_node
+      alias on_zsuper     process_regular_node
+      alias on_jscall     on_send
+      alias on_jsattr     process_regular_node
+      alias on_jsattrasgn process_regular_node
+      alias on_kwsplat    process_regular_node
+
+      # Prepends given +node+ to +body+ node.
+      #
+      # Supports +body+ to be one of:
+      # 1. nil                     - empty body
+      # 2. s(:begin) / s(:kwbegin) - multiline body
+      # 3. s(:anything_else)       - singleline body
+      #
+      # Returns a new body with +node+ injected as a first statement.
+      #
+      def prepend_to_body(body, node)
+        if body.nil?
+          node
+        elsif [:begin, :kwbegin].include?(body.type)
+          body.updated(nil, [node, *body])
+        else
+          s(:begin, node, body)
+        end
+      end
+
+      # Appends given +node+ to +body+ node.
+      #
+      # Supports +body+ to be one of:
+      # 1. nil                     - empty body
+      # 2. s(:begin) / s(:kwbegin) - multiline body
+      # 3. s(:anything_else)       - singleline body
+      #
+      # Returns a new body with +node+ injected as a last statement.
+      #
+      def append_to_body(body, node)
+        if body.nil?
+          node
+        elsif [:begin, :kwbegin].include?(body.type)
+          body.updated(nil, [*body, node])
+        else
+          s(:begin, body, node)
+        end
+      end
+    end
+  end
+end

data/lib/opal/rewriters/binary_operator_assignment.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class BinaryOperatorAssignment < Base
+      def self.reset_tmp_counter!
+        @@counter = 0
+      end
+
+      def self.new_temp
+        @@counter ||= 0
+        @@counter += 1
+        :"$binary_op_recvr_tmp_#{@@counter}"
+      end
+
+      GET_SET = ->(get_type, set_type) {
+
+        ->(lhs, op, rhs) {
+          get_node = lhs.updated(get_type) # lhs
+          set_node = s(:send, get_node, op, rhs) # lhs + rhs
+
+          lhs.updated(set_type, [*lhs, set_node]) # lhs = lhs + rhs
+        }
+
+      }
+
+      # Takes    `lhs += rhs`
+      # Produces `lhs = lhs + rhs`
+      LocalVariableHandler = GET_SET[:lvar, :lvasgn]
+
+      # Takes    `@lhs += rhs`
+      # Produces `@lhs = @lhs + rhs`
+      InstanceVariableHandler = GET_SET[:ivar, :ivasgn]
+
+      # Takes    `LHS += rhs`
+      # Produces `LHS = LHS + rhs`
+      ConstantHandler = GET_SET[:const, :casgn]
+
+      # Takes    `$lhs += rhs`
+      # Produces `$lhs = $lhs + rhs`
+      GlobalVariableHandler = GET_SET[:gvar, :gvasgn]
+
+      # Takes    `@@lhs += rhs`
+      # Produces `@@lhs = @@lhs + rhs`
+      ClassVariableHandler = GET_SET[:cvar, :cvasgn]
+
+      # Takes    `recvr.meth += rhs`
+      # Produces `recvr.meth = recvr.meth + rhs`
+      # (lhs is a recvr.meth, op is :+)
+      class SendHandler < self
+        def self.call(lhs, op, rhs)
+          recvr, reader_method, *args = *lhs
+
+          # If recvr is a complex expression it must be cached.
+          # MRI calls recvr in `recvr.meth ||= rhs` only once.
+          if recvr && recvr.type == :send
+            recvr_tmp = new_temp
+            cache_recvr = s(:lvasgn, recvr_tmp, recvr)                         # $tmp = recvr
+            recvr = s(:js_tmp, recvr_tmp)
+          end
+
+          writer_method = :"#{reader_method}="
+
+          call_reader = lhs.updated(:send, [recvr, reader_method, *args])      # $tmp.meth
+          call_op = s(:send, call_reader, op, rhs) # $tmp.meth + rhs
+          call_writer = lhs.updated(:send, [recvr, writer_method, *args, call_op]) # $tmp.meth = $tmp.meth + rhs
+
+          if cache_recvr
+            s(:begin, cache_recvr, call_writer)
+          else
+            call_writer
+          end
+        end
+      end
+
+      # Takes    `recvr.meth += rhs`
+      # Produces `recvr.nil? ? nil : recvr.meth += rhs`
+      #   NOTE: Later output of this handler gets post-processed by this rewriter again
+      #   using SendHandler to `recvr.nil? ? nil : (recvr.meth = recvr.meth + rhs)`
+      class ConditionalSendHandler < self
+        def self.call(lhs, op, rhs)
+          recvr, meth, *args = *lhs
+
+          recvr_tmp = new_temp
+          cache_recvr = s(:lvasgn, recvr_tmp, recvr)          # $tmp = recvr
+          recvr = s(:js_tmp, recvr_tmp)
+
+          recvr_is_nil = s(:send, recvr, :nil?)                 # recvr.nil?
+          plain_send = lhs.updated(:send, [recvr, meth, *args]) # recvr.meth
+          plain_op_asgn = s(:op_asgn, plain_send, op, rhs)      # recvr.meth += rhs
+
+          s(:begin,
+            cache_recvr,
+            s(:if, recvr_is_nil,                          # if recvr.nil?
+              s(:nil),                                    #   nil
+                                                          # else
+              plain_op_asgn))                             #   recvr.meth ||= rhs
+                                                          # end
+        end
+      end
+
+      HANDLERS = {
+        lvasgn: LocalVariableHandler,
+        ivasgn: InstanceVariableHandler,
+        casgn:  ConstantHandler,
+        gvasgn: GlobalVariableHandler,
+        cvasgn: ClassVariableHandler,
+        send:   SendHandler,
+        csend:  ConditionalSendHandler
+      }
+
+      # lhs += rhs
+      def on_op_asgn(node)
+        lhs, op, rhs = *node
+
+        result = HANDLERS
+          .fetch(lhs.type) { raise NotImplementedError }
+          .call(lhs, op, rhs)
+
+        process(result)
+      end
+
+      ASSIGNMENT_STRING_NODE = s(:str, 'assignment')
+
+      # Rewrites any or_asgn and and_asgn node like
+      #   `defined?(a ||= 1)`
+      # and
+      #   `defined?(a &&= 1)`
+      # to a static "assignment" string node
+      def on_defined?(node)
+        inner, _ = *node
+        if inner.type == :op_asgn
+          ASSIGNMENT_STRING_NODE
+        else
+          super(node)
+        end
+      end
+    end
+  end
+end

data/lib/opal/rewriters/block_to_iter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class BlockToIter < Base
+      def on_block(node)
+        recvr, args, body = *super
+        iter_node = s(:iter, args, body)
+        recvr.updated(
+          nil,
+          recvr.children + [iter_node]
+        )
+      end
+    end
+  end
+end

data/lib/opal/rewriters/break_finder.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require 'opal/rewriter'
+
+module Opal
+  module Rewriters
+    class BreakFinder < Opal::Rewriters::Base
+      def initialize
+        @found_break = false
+      end
+
+      def found_break?
+        @found_break
+      end
+
+      def on_break(node)
+        @found_break = true
+        node
+      end
+
+      def stop_lookup(node)
+      end
+
+      # regular loops
+      alias on_for        stop_lookup
+      alias on_while      stop_lookup
+      alias on_while_post stop_lookup
+      alias on_until      stop_lookup
+      alias on_until_post stop_lookup
+
+      # nested block
+      alias on_block      stop_lookup
+    end
+  end
+end

data/lib/opal/rewriters/dot_js_syntax.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class DotJsSyntax < Base
+      def on_send(node)
+        recv, meth, *args = *node
+        if recv && recv.type == :send
+          recv_of_recv, meth_of_recv, _ = *recv
+          if meth_of_recv == :JS
+            case meth
+            when :[]
+              if args.size != 1
+                raise SyntaxError, ".JS[:property] syntax supports only one argument"
+              end
+              property = args.first
+
+              node = to_js_attr_call(recv_of_recv, property)
+            when :[]=
+              if args.size != 2
+                raise SyntaxError, '.JS[:property]= syntax supports only two arguments'
+              end
+
+              property, value = *args
+              node = to_js_attr_assign_call(recv_of_recv, property, value)
+            else
+              node = to_native_js_call(recv_of_recv, meth, args)
+            end
+            super(node)
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      # @param recv [AST::Node] receiver of .JS. method
+      # @param meth [Symbol] name of the JS method
+      # @param args [Array<AST::Node>] list of the arguments passed to JS method
+      def to_native_js_call(recv, meth, args)
+        s(:jscall, recv, meth, *args)
+      end
+
+      # @param recv [AST::Node] receiver of .JS[] method
+      # @param property [AST::Node] argument passed to .JS[] method
+      def to_js_attr_call(recv, property)
+        s(:jsattr, recv, property)
+      end
+
+      # @param recv [AST::Node] receiver of .JS[]= method
+      # @param property [AST::Node] property passed to brackets
+      # @param value [AST::Node] value of assignment
+      def to_js_attr_assign_call(recv, property, value)
+        s(:jsattrasgn, recv, property, value)
+      end
+    end
+  end
+end

data/lib/opal/rewriters/explicit_writer_return.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class ExplicitWriterReturn < Base
+      def initialize
+        @in_masgn = false
+      end
+
+      TMP_NAME = '$writer'
+      GET_ARGS_NODE = s(:lvar, TMP_NAME)
+      RETURN_ARGS_NODE = s(:jsattr,
+        GET_ARGS_NODE,
+        s(:send, s(:jsattr, GET_ARGS_NODE, s(:str, 'length')), :-, s(:int, 1))
+      )
+
+      def on_send(node)
+        return super if @in_masgn
+
+        recv, method_name, *args = *node
+
+        if method_name.to_s =~ /#{REGEXP_START}\w+=#{REGEXP_END}/ || method_name.to_s == "[]="
+          set_args_node = s(:lvasgn, TMP_NAME, s(:array, *process_all(args)))
+
+          s(:begin,
+            set_args_node,
+            node.updated(nil, [recv, method_name, s(:splat, GET_ARGS_NODE)]),
+            RETURN_ARGS_NODE
+          )
+        else
+          super
+        end
+      end
+
+      # Multiple assignment is handled by Opal::Nodes::MassAssignNode
+      #
+      # For example, "self.a, self.b = 1, 2" parses to:
+      # s(:masgn,
+      #   s(:mlhs,
+      #     s(:send,
+      #       s(:self), :a=),
+      #     s(:send,
+      #       s(:self), :b=)),
+      #   s(:array,
+      #     s(:int, 1),
+      #     s(:int, 2)))
+      #
+      # And this AST rewriter skips this node.
+      def on_masgn(node)
+        @in_masgn = true
+        result = super
+        @in_masgn = false
+        result
+      end
+    end
+  end
+end

data/lib/opal/rewriters/for_rewriter.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class ForRewriter < Base
+      def self.reset_tmp_counter!
+        @counter = 0
+      end
+
+      def self.next_tmp
+        @counter ||= 0
+        @counter += 1
+        :"$for_tmp#{@counter}"
+      end
+
+      # Handles
+      #   for i in 0..3; j = i + 1; end
+      #
+      # The problem here is that in Ruby for loop makes its
+      # loop variable + all local variables available outside.
+      # I.e. after this loop variable `i` is 3 and `j` is 4
+      #
+      # This class rewrites it to the following code:
+      #   j = nil
+      #   i = nil
+      #   (0..3).each { |__jstmp| i = __jstmp; j = i + 1 }
+      #
+      # Complex stuff with multiple loop variables:
+      #   for i, j in [[1, 2], [3, 4]]; end
+      # Becomes multiple left-hand assignment:
+      #   i = nil
+      #   j = nil
+      #   [[1, 2], [3, 4]].each { |__jstmp| i, j = __jstmp }
+      #
+      def on_for(node)
+        loop_variable, iterating_value, loop_body = *node
+
+        iterating_lvars        = LocalVariableAssigns.find(loop_variable) # [:i]
+        lvars_declared_in_body = LocalVariableAssigns.find(loop_body)     # [:j]
+
+        # i = nil; j = nil
+        outer_assigns = (iterating_lvars + lvars_declared_in_body).map do |lvar_name|
+          s(:lvdeclare, lvar_name)
+        end
+
+        # :__jstmp
+        tmp_loop_variable = self.class.next_tmp
+        get_tmp_loop_variable = s(:js_tmp, tmp_loop_variable)
+
+        loop_variable_assignment = case loop_variable.type
+        when :mlhs # multiple left-hand statement like in "for i,j in [[1, 2], [3, 4]]"
+          # i, j = __jstmp
+          s(:masgn, loop_variable, get_tmp_loop_variable)
+        else # single argument like "for i in (0..3)"
+          # i = __jstmp
+          loop_variable << get_tmp_loop_variable
+        end
+
+        loop_body = prepend_to_body(loop_body, loop_variable_assignment)
+
+        node = s(:send, iterating_value, :each,          # (0..3).each {
+          s(:iter, s(:args, s(:arg, tmp_loop_variable)), #                |__jstmp|
+          loop_body)                                     #                          i = __jstmp; j = i + 1 }
+        )
+
+        s(:begin, *outer_assigns, node)
+      end
+
+      private
+
+      class LocalVariableAssigns < Base
+        attr_reader :result
+
+        def self.find(node)
+          processor = new
+          processor.process(node)
+          processor.result.to_a
+        end
+
+        def initialize
+          @result = Set.new
+        end
+
+        def on_lvasgn(node)
+          name, _ = *node
+          self.result << name
+          super
+        end
+      end
+    end
+  end
+end

data/lib/opal/rewriters/hashes/key_duplicates_rewriter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require 'opal/rewriters/base'
+require 'set'
+
+module Opal
+  module Rewriters
+    module Hashes
+      class KeyDuplicatesRewriter < ::Opal::Rewriters::Base
+        def initialize
+          @keys = UniqKeysSet.new
+        end
+
+        def on_hash(node)
+          previous_keys, @keys = @keys, UniqKeysSet.new
+          super(node)
+        ensure
+          @keys = previous_keys
+        end
+
+        def on_pair(node)
+          key, _value = *node
+
+          if %i(str sym).include?(key.type)
+            @keys << key
+          end
+
+          super(node)
+        end
+
+        def on_kwsplat(node)
+          hash, _ = *node
+
+          if hash.type == :hash
+            hash = process_regular_node(hash)
+          end
+
+          node.updated(nil, [hash])
+        end
+
+        class UniqKeysSet
+          def initialize
+            @set = Set.new
+          end
+
+          def <<(element)
+            if @set.include?(element)
+              key, _ = *element
+              key = element.type == :str ? key.inspect : ":#{key}"
+              Kernel.warn "warning: key #{key} is duplicated and overwritten"
+            else
+              @set << element
+            end
+          end
+        end
+      end
+    end
+  end
+end