opal 0.10.0.beta2 → 0.10.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b0d30f54134e49ebcd91c2ece0dd0cf54a6d72ae
-  data.tar.gz: 57d3c8e202237d2e452523b1d772d8ddfe3baa24
+  metadata.gz: 6e7bea1b676089d0921e603acafc794fe81fb671
+  data.tar.gz: 798d0eef513a0f7a17eb283d810342ffddb64b03
 SHA512:
-  metadata.gz: 0417410d72d8b82f366042085243ccd06d6d4394e46dbe507a3834e9df68d2ec5c76585b660466888ea6d3e8618e96f551e1e3482c3e66b0f270f5a9c4051482
-  data.tar.gz: da1d154ccf0f0ae319bed44b962e2ef6a588af39d22ede501cd7af7c7d8f095c9223bee1ecf0bafdf6b8500f605589d7c2b814daaf841b9caf5707ea6d0602a4
+  metadata.gz: c349f1c93f09a28b2e0c9285008901d985c4196548171318fadcd416e370e9dc2bcbc4d8b1e184b5e4646206e8c64efee28c58d8a4e11a0939eceb21f929912c
+  data.tar.gz: 5af01ed324f7c9f0eec062d465d34e051d47bca3e24e33c72e17e6634a7b87cab060f303b3408a5644763e838c3051d29964f8e6d461408f8a18cd2726ceacfa

data/CHANGELOG.md

@@ -26,6 +26,7 @@ Whitespace conventions:
 
 ### Added
 
+- Source maps now include method names
 - `Module#included_modules` works
 - Internal runtime cleanup (#1241)
 - Make it easier to add custom runners for the CLI (#1261)
@@ -50,6 +51,7 @@ Whitespace conventions:
 - Super works with define_method blocks
 - Added support for kwsplats.
 - Added support for squiggly heredoc.
+- Implement `Method#parameters` and `Proc#parameters`.
 
 
 ### Changed
@@ -57,8 +59,9 @@ Whitespace conventions:
 - Remove deprecation of `Opal::Environment` after popular request
 - Setting `Opal::Config.dynamic_require_severity` will no longer affect `Opal.dynamic_require_severity` which now needs to be explicitly set if it differs from the default value of `"warning"` (See also the `Opal.dynamic_require_severity` rename below).
 - The new default for `Opal::Config.dynamic_require_severity` is now `:warning`
-- `Opal.dynamic_require_severity` and `OPAL_CONFIG` are now merged into `Opal.config.missing_require_severity` (defaults to `error`, the expected ruby behavior) and `Opal.config.unsupported_features_severity` (defaults to `warning`, e.g. a one-time heads up that freezing isn't supported)
+- `Opal.dynamic_require_severity` and `OPAL_CONFIG` are now merged into `Opal.config.missing_require_severity` (defaults to `error`, the expected ruby behavior) and `Opal.config.unsupported_features_severity` (defaults to `warning`, e.g. a one-time heads up that freezing isn't supported). Added variable `__OPAL_COMPILER_CONFIG__` that contains compiler options that may be used in runtime.
 - `Hash` instances should now list the string map (`$$smap`) as the first key, making debugging easier (most hashes will just have keys there).
+- Handle Pathname object in Pathname constructor
 
 
 ### Deprecated
@@ -75,6 +78,10 @@ Whitespace conventions:
 
 ### Fixed
 
+- `Pathname#absolute?` and `Pathname#relative?` now work properly
+- `File::dirname` and `File::basename` are now Rubyspec compliant
+- `SourceMap::VLQ` patch (#1075)
+- `Regexp::new` no longer throws error when the expression ends in \\\\
 - `super` works properly with overwritten alias methods (#1384)
 - `NoMethodError` does not need a name to be instantiated
 - `method_added` fix for singleton class cases
@@ -106,6 +113,7 @@ Whitespace conventions:
 - Fixed an issue with `"-"` inside the second arg of `String#tr`
 - Fixed Base64 and enabled specs
 - Fixed method definition in method body.
+- Partially implemented `Marshal.load`/`Marshal.dump`. In order to use it require `opal/full`.
 
 
 ### Removed

data/lib/opal/compiler.rb

@@ -106,7 +106,7 @@ module Opal
     # @!method dynamic_require_severity
     #
     # how to handle dynamic requires (:error, :warning, :ignore)
-    compiler_option :dynamic_require_severity, :error, :valid_values => [:error, :warning, :ignore]
+    compiler_option :dynamic_require_severity, :warning, :valid_values => [:error, :warning, :ignore]
 
     # @!method requirable?
     #
@@ -148,13 +148,19 @@ module Opal
     def compile
       @parser = Parser.new
 
-      @sexp = s(:top, @parser.parse(@source, self.file) || s(:nil))
+      parsed = begin
+        @parser.parse(@source, self.file)
+      rescue => error
+        raise SyntaxError, error.message, error.backtrace
+      end
+
+      @sexp = s(:top, parsed || s(:nil))
       @eof_content = @parser.lexer.eof_content
 
       @fragments = process(@sexp).flatten
 
       @result = @fragments.map(&:code).join('')
-    rescue => error
+    rescue Exception => error
       message = "An error occurred while compiling: #{self.file}\n#{error.message}"
       raise error.class, message, error.backtrace
     end
@@ -215,8 +221,8 @@ module Opal
       Sexp.new(parts)
     end
 
-    def fragment(str, sexp = nil)
-      Fragment.new(str, sexp)
+    def fragment(str, scope, sexp = nil)
+      Fragment.new(str, scope, sexp)
     end
 
     # Used to generate a unique id name per file. These are used
@@ -320,7 +326,7 @@ module Opal
     # Process the given sexp by creating a node instance, based on its type,
     # and compiling it to fragments.
     def process(sexp, level = :expr)
-      return fragment('') if sexp == nil
+      return fragment('', scope) if sexp == nil
 
       if handler = handlers[sexp.type]
         return handler.new(sexp, level, self).compile_to_fragments
@@ -428,11 +434,11 @@ module Opal
     def handle_block_given_call(sexp)
       @scope.uses_block!
       if @scope.block_name
-        fragment("(#{@scope.block_name} !== nil)", sexp)
+        fragment("(#{@scope.block_name} !== nil)", scope, sexp)
       elsif scope = @scope.find_parent_def and scope.block_name
-        fragment("(#{scope.block_name} !== nil)", sexp)
+        fragment("(#{scope.block_name} !== nil)", scope, sexp)
       else
-        fragment("false", sexp)
+        fragment("false", scope, sexp)
       end
     end
   end

data/lib/opal/fragment.rb

@@ -15,9 +15,10 @@ module Opal
     #
     # @param code [String] javascript code
     # @param sexp [Opal::Sexp] sexp used for creating fragment
-    def initialize(code, sexp = nil)
+    def initialize(code, scope, sexp = nil)
       @code = code.to_s
       @sexp = sexp
+      @scope = scope
     end
 
     # Inspect the contents of this fragment, f("fooo")
@@ -25,6 +26,12 @@ module Opal
       "f(#{@code.inspect})"
     end
 
+    def source_map_name
+      return nil unless @scope
+      def_node = @scope.def? ? @scope : @scope.find_parent_def
+      def_node && def_node.mid
+    end
+
     # Original line this fragment was created from
     # @return [Integer, nil]
     def line

data/lib/opal/nodes/args/restarg.rb

@@ -25,7 +25,12 @@ module Opal
           # inline restarg case
           offset = @sexp.meta[:offset]
           # restarg value should be taken directly from parameters
-          line "#{var_name} = $slice.call(arguments, #{offset}, arguments.length);"
+          line "var $args_len = arguments.length, $rest_len = $args_len - #{offset};"
+          line "if ($rest_len < 0) { $rest_len = 0; }"
+          line "#{var_name} = new Array($rest_len);"
+          line "for (var $arg_idx = #{offset}; $arg_idx < $args_len; $arg_idx++) {"
+          line "  #{var_name}[$arg_idx - #{offset}] = arguments[$arg_idx];"
+          line "}"
         end
       end
     end

data/lib/opal/nodes/base.rb

@@ -72,7 +72,7 @@ module Opal
       end
 
       def fragment(str)
-        Opal::Fragment.new str, @sexp
+        Opal::Fragment.new str, scope, @sexp
       end
 
       def error(msg)

data/lib/opal/nodes/call.rb

@@ -291,6 +291,10 @@ module Opal
         push fragment 'debugger'
       end
 
+      add_special :__OPAL_COMPILER_CONFIG__ do
+        push fragment "Opal.hash({ arity_check: #{compiler.arity_check?} })"
+      end
+
       class DependencyResolver
         def initialize(compiler, sexp)
           @compiler = compiler

data/lib/opal/nodes/def.rb

@@ -12,21 +12,10 @@ module Opal
 
       def extract_block_arg
         if args.last.is_a?(Sexp) && args.last.type == :blockarg
-          @block_arg = args.pop
+          @block_arg = args.pop[1]
         end
       end
 
-      def argc
-        return @argc if @argc
-
-        @argc = args.length - 1
-        @argc -= 1 if block_arg
-        @argc -= 1 if rest_arg
-        @argc -= keyword_args.size
-
-        @argc
-      end
-
       def compile
         extract_block_arg
         split_args
@@ -36,11 +25,7 @@ module Opal
 
         # block name (&block)
         if block_arg
-          block_name = variable(block_arg[1]).to_sym
-        end
-
-        if compiler.arity_check?
-          arity_code = arity_check(args, opt_args, rest_arg, keyword_args, block_name, mid)
+          block_name = variable(block_arg).to_sym
         end
 
         in_scope do
@@ -62,6 +47,12 @@ module Opal
           compile_inline_args
           compile_post_args
 
+          scope.identify!
+
+          if compiler.arity_check?
+            arity_code = arity_check(mid)
+          end
+
           scope_name = scope.identity
 
           compile_block_arg
@@ -100,6 +91,12 @@ module Opal
         unshift "#{scope_name} = " if scope_name
         line "}"
 
+        push ", #{scope_name}.$$arity = #{arity}"
+
+        if compiler.arity_check?
+          push ", #{scope_name}.$$parameters = #{parameters_code}"
+        end
+
         if recvr
           unshift 'Opal.defs(', recv(recvr), ", '$#{mid}', "
           push ')'
@@ -130,18 +127,17 @@ module Opal
       end
 
       # Returns code used in debug mode to check arity of method call
-      def arity_check(args, opt, splat, kwargs, block_name, mid)
+      def arity_check(mid)
         meth = mid.to_s.inspect
 
         arity = args.size - 1
-        arity -= (opt.size)
+        arity -= (opt_args.size)
 
-        arity -= 1 if splat
+        arity -= 1 if rest_arg
 
-        arity -= (kwargs.size)
+        arity -= (keyword_args.size)
 
-        # arity -= 1 if block_name
-        arity = -arity - 1 if !opt.empty? or !kwargs.empty? or splat
+        arity = -arity - 1 if !opt_args.empty? or !keyword_args.empty? or rest_arg
 
         # $arity will point to our received arguments count
         aritycode = "var $arity = arguments.length;"
@@ -149,10 +145,9 @@ module Opal
         if arity < 0 # splat or opt args
           min_arity = -(arity + 1)
           max_arity = args.size - 1
-          # max_arity -= 1 if block_name
           checks = []
           checks << "$arity < #{min_arity}" if min_arity > 0
-          checks << "$arity > #{max_arity}" if max_arity and not(splat)
+          checks << "$arity > #{max_arity}" if max_arity and not(rest_arg)
           aritycode + "if (#{checks.join(' || ')}) { Opal.ac($arity, #{arity}, this, #{meth}); }" if checks.size > 0
         else
           aritycode + "if ($arity !== #{arity}) { Opal.ac($arity, #{arity}, this, #{meth}); }"

data/lib/opal/nodes/hash.rb

@@ -5,40 +5,101 @@ module Opal
     class HashNode < Base
       handle :hash
 
-      def extract_keys_and_values(pairs)
-        keys, values = [], []
+      attr_accessor :has_kwsplat, :keys, :values
 
-        pairs.each_with_index do |obj, idx|
+      def initialize(*)
+        super
+        @has_kwsplat = false
+        @keys = []
+        @values = []
+      end
+
+      # Splits keys/values/kwsplats
+      #
+      # hash like { **{ nested: 1 }, d: 2 }
+      # is represetned by sexp:
+      # (:hash,
+      #   (:kwsplat,
+      #     (:hash,
+      #       (:sym, :nested),
+      #       (:int, 1)
+      #     )
+      #   ),
+      #   (:sym, :d),
+      #   (:int, 2),
+      # )
+      # So k/v pairs and kwsplats can be mixed in any order.
+      def extract_kv_pairs_and_kwsplats
+        found_key = false
+
+        children.each do |obj|
           if obj.type == :kwsplat
-            # obj is (:kwsplat, (:hash, (:key, value), ...))
-            kwsplat_pairs = obj[1].children
-            kwsplat_keys, kwsplat_values = extract_keys_and_values(kwsplat_pairs)
-            keys.concat(kwsplat_keys)
-            values.concat(kwsplat_values)
-          elsif idx.even?
-            keys << obj
-          else
+            self.has_kwsplat = true
+          elsif found_key
             values << obj
+            found_key = false
+          else
+            keys << obj
+            found_key = true
           end
         end
 
         [keys, values]
       end
 
-      def simple_keys?(keys)
-        keys.all? { |key| [:sym, :str].include? key.type }
+      def simple_keys?
+        keys.all? { |key| [:sym, :str].include?(key.type) }
       end
 
       def compile
-        keys, values = extract_keys_and_values(children)
+        extract_kv_pairs_and_kwsplats
 
-        if simple_keys? keys
-          compile_hash2 keys, values
+        if has_kwsplat
+          compile_merge
+        elsif simple_keys?
+          compile_hash2
         else
           compile_hash
         end
       end
 
+      # Compiles hashes containing kwsplats inside.
+      # hash like { **{ nested: 1 }, a: 1, **{ nested: 2} }
+      # should be compiled to
+      # { nested: 1}.merge(a: 1).merge(nested: 2)
+      # Each kwsplat overrides previosly defined keys
+      # Hash k/v pairs override previously defined kwsplat values
+      def compile_merge
+        helper :hash
+
+        result, seq = [], []
+
+        children.each do |child|
+          if child.type == :kwsplat
+            unless seq.empty?
+              result << expr(s(:hash, *seq))
+            end
+            result << expr(child)
+            seq = []
+          else
+            seq << child
+          end
+        end
+        unless seq.empty?
+          result << expr(s(:hash, *seq))
+        end
+
+        result.each_with_index do |fragment, idx|
+          if idx == 0
+            push fragment
+          else
+            push ".$merge(", fragment, ")"
+          end
+        end
+      end
+
+      # Compiles a hash without kwsplats
+      # with complex keys.
       def compile_hash
         helper :hash
 
@@ -50,7 +111,9 @@ module Opal
         wrap '$hash(', ')'
       end
 
-      def compile_hash2(keys, values)
+      # Compiles a hash without kwsplats
+      # and containing **only** string/symbols as keys.
+      def compile_hash2
         hash_obj, hash_keys = {}, []
         helper :hash2
 
@@ -69,5 +132,14 @@ module Opal
         wrap "$hash2([#{hash_keys.join ', '}], {", "})"
       end
     end
+
+    class KwSplatNode < Base
+      handle :kwsplat
+      children :value
+
+      def compile
+        push "Opal.to_hash(", expr(value), ")"
+      end
+    end
   end
 end

data/lib/opal/nodes/iter.rb

@@ -15,8 +15,6 @@ module Opal
         extract_shadow_args
         split_args
 
-        # require 'pry'; binding.pry
-
         to_vars = identity = body_code = nil
 
         in_scope do
@@ -44,6 +42,28 @@ module Opal
         unshift "(#{identity} = function(", inline_params, "){"
         push "}, #{identity}.$$s = self,"
         push " #{identity}.$$brk = $brk," if compiler.has_break?
+        push " #{identity}.$$arity = #{arity},"
+
+        if compiler.arity_check?
+          push " #{identity}.$$parameters = #{parameters_code},"
+        end
+
+        # MRI expands a passed argument if the block:
+        # 1. takes a single argument that is an array
+        # 2. has more that one argument
+        # With a few exceptions:
+        # 1. mlhs arg: if a block takes |(a, b)| argument
+        # 2. trailing ',' in the arg list (|a, |)
+        # This flag on the method indicates that a block has a top level mlhs argument
+        # which means that we have to expand passed array explicitly in runtime.
+        if has_top_level_mlhs_arg?
+          push " #{identity}.$$has_top_level_mlhs_arg = true,"
+        end
+
+        if has_trailing_comma_in_args?
+          push " #{identity}.$$has_trailing_comma_in_args = true,"
+        end
+
         push " #{identity})"
       end
 
@@ -122,6 +142,14 @@ module Opal
       def mlhs_args
         scope.mlhs_mapping.keys
       end
+
+      def has_top_level_mlhs_arg?
+        args.children.any? { |arg| arg.type == :mlhs }
+      end
+
+      def has_trailing_comma_in_args?
+        args.meta[:has_trailing_comma]
+      end
     end
   end
 end