opal 0.11.0.rc1 → 0.11.0

data/lib/opal/parser.rb

@@ -2,34 +2,39 @@
 require 'opal/ast/builder'
 require 'opal/rewriter'
 
-if RUBY_ENGINE == 'opal'
-  class << Parser::Source::Buffer
-    def recognize_encoding(s)
-      Encoding::UTF_8
+module Opal
+  module Source
+    class Buffer < Parser::Source::Buffer
+      def self.recognize_encoding(string)
+        super || Encoding::UTF_8
+      end
     end
   end
-end
 
-module Opal
   class Parser < ::Parser::Ruby23
-    def initialize(*)
-      super(Opal::AST::Builder.new)
-    end
+    class << self
+      attr_accessor :diagnostics_consumer
 
-    def self.default_parser
-      parser = super
+      def default_parser
+        parser = super
 
-      parser.diagnostics.all_errors_are_fatal = true
-      parser.diagnostics.ignore_warnings      = true
+        parser.diagnostics.all_errors_are_fatal = true
+        parser.diagnostics.ignore_warnings      = false
 
-      if RUBY_ENGINE == 'opal'
-        parser.diagnostics.consumer = ->(diag){}
-      else
-        parser.diagnostics.consumer = lambda do |diagnostic|
-          $stderr.puts(diagnostic.render)
+        if RUBY_ENGINE == 'opal'
+          parser.diagnostics.consumer = ->(diag){}
+        else
+          parser.diagnostics.consumer = diagnostics_consumer
         end
+
+        parser
       end
-      parser
+    end
+
+    self.diagnostics_consumer = ->(diagnostic) { $stderr.puts(diagnostic.render) }
+
+    def initialize(*)
+      super(Opal::AST::Builder.new)
     end
 
     def parse(source_buffer)

data/lib/opal/path_reader.rb

@@ -1,13 +1,16 @@
 # frozen_string_literal: true
 require 'opal/regexp_anchors'
-require 'opal/hike_path_finder'
+require 'hike'
 
 module Opal
   class PathReader
     RELATIVE_PATH_REGEXP = %r{#{Opal::REGEXP_START}\.?\.#{Regexp.quote File::SEPARATOR}}
+    DEFAULT_EXTENSIONS = ['.js', '.js.rb', '.rb', '.opalerb']
 
-    def initialize(file_finder = HikePathFinder.new)
-      @file_finder = file_finder
+    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)
@@ -20,7 +23,7 @@ module Opal
       if Pathname.new(path).absolute? || path =~ RELATIVE_PATH_REGEXP
         path
       else
-        file_finder.find(path)
+        find_path(path)
       end
     end
 
@@ -28,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/rewriter.rb

@@ -1,11 +1,13 @@
 # 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
@@ -30,17 +32,19 @@ module Opal
       end
 
       def disabled?
-        @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

data/lib/opal/rewriters/base.rb

@@ -13,46 +13,49 @@ module Opal
         ::Opal::AST::Node.new(type, children)
       end
 
-      alias on_iter process_regular_node
-      alias on_top  process_regular_node
-
-      # TODO: remove patches above after releasing
-      # https://github.com/whitequark/parser/commit/cd8d5db
-      def on_vasgn(node)
-        name, value_node = *node
-
-        if !value_node.nil?
-          node.updated(nil, [
-            name, process(value_node)
-          ])
-        else
+      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
-        end
-      end
-
-      def on_casgn(node)
-        scope_node, name, value_node = *node
-
-        if !value_node.nil?
-          node.updated(nil, [
-            process(scope_node), name, process(value_node)
-          ])
+        elsif [:begin, :kwbegin].include?(body.type)
+          body.updated(nil, [node, *body])
         else
-          node.updated(nil, [
-            process(scope_node), name
-          ])
+          s(:begin, node, body)
         end
       end
 
-      def on_argument(node)
-        arg_name, value_node = *node
-
-        if !value_node.nil?
-          node.updated(nil, [
-            arg_name, process(value_node)
-          ])
-        else
+      # 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

data/lib/opal/rewriters/binary_operator_assignment.rb

@@ -80,8 +80,6 @@ module Opal
       #   using SendHandler to `recvr.nil? ? nil : (recvr.meth = recvr.meth + rhs)`
       class ConditionalSendHandler < self
         def self.call(lhs, op, rhs)
-          root_type = :op_asgn
-
           recvr, meth, *args = *lhs
 
           recvr_tmp = new_temp
@@ -89,7 +87,6 @@ module Opal
           recvr = s(:js_tmp, recvr_tmp)
 
           recvr_is_nil = s(:send, recvr, :nil?)                 # recvr.nil?
-          nil_node = s(:nil)                                    # nil
           plain_send = lhs.updated(:send, [recvr, meth, *args]) # recvr.meth
           plain_op_asgn = s(:op_asgn, plain_send, op, rhs)      # recvr.meth += rhs
 

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

data/lib/opal/rewriters/js_reserved_words.rb

@@ -89,22 +89,19 @@ module Opal
         name, _ = *node
 
         if name
-          node = node.updated(nil, [fix_var_name(name)])
+          node = node.updated(nil, [fix_var_name(name)], meta: {arg_name: name})
         end
 
         node
       end
 
       def on_argument(node)
+        node = super(node)
         name, value = *node
+        fixed_name = fix_var_name(name)
+        new_children = value ? [fixed_name, value] : [fixed_name]
 
-        if value
-          node = node.updated(nil, [fix_var_name(name), value])
-        else
-          node = node.updated(nil, [fix_var_name(name)])
-        end
-
-        super(node)
+        node.updated(nil, new_children, meta: {arg_name: name})
       end
     end
   end

data/lib/opal/rewriters/logical_operator_assignment.rb

@@ -89,7 +89,6 @@ module Opal
           recvr = s(:js_tmp, recvr_tmp)
 
           recvr_is_nil = s(:send, recvr, :nil?)                 # recvr.nil?
-          nil_node = s(:nil)                                    # nil
           plain_send = lhs.updated(:send, [recvr, meth, *args]) # recvr.meth
           plain_or_asgn = s(root_type, plain_send, rhs)         # recvr.meth ||= rhs
 

data/lib/opal/simple_server.rb

@@ -17,6 +17,7 @@ class Opal::SimpleServer
   def initialize(options = {})
     @prefix = options.fetch(:prefix, 'assets')
     @main = options.fetch(:main, 'application')
+    @index_path = nil
     yield self if block_given?
     freeze
   end

data/lib/opal/util.rb

@@ -12,7 +12,7 @@ module Opal
     # @param str [String] string to minify
     # @return [String]
     def uglify(str)
-      uglifyjs = DigestSourceCommand.new(:uglifyjs, nil, ' (install with: "npm install -g uglify-js")')
+      uglifyjs = DigestSourceCommand.new(:uglifyjs, '-c', ' (install with: "npm install -g uglify-js")')
       uglifyjs.digest(str)
     end