opal 0.9.0.beta1 → 0.9.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1af59805d32671acdce95d17776362c714d82c6d
-  data.tar.gz: cbe41468214bfdd99902f85301182b37a4281a8a
+  metadata.gz: a71d75efaebcd98ae54fc1221323252c84d83725
+  data.tar.gz: 81f52eea1fb84c5bb009ccd90bdf4cbc2f8344a8
 SHA512:
-  metadata.gz: 280f8bc25e11405068eb0794bc3c094885f2b43266b9dfa8716e1f25009118a5c0556ed8b8d489f1f406cc862817753fb70065eda5e744c3f2f0de142607611b
-  data.tar.gz: d4ad1d81debb785c025807f6d18281dd191df37efef3afb2d548e611aa36ecb44bbe43846a8fe900f03cec73ec1be0159483d3c18f373eda3beda498bb16aa2b
+  metadata.gz: c9fa8aa94a8350f9ec2bde008a844c4fb09d5b05917abc21045791b584adef85951106190840e50b29e047ad0f464e0acfbee5e8ac5ba2872ffac59574efc136
+  data.tar.gz: 3744c8d573fa179442543ad09d876ee64d56b2d0114c151cc2789821741c52206edce4c0ba798658d91ee3c25679aa37b37c3eb5548e6d1611a3a68b42409f5c

data/CHANGELOG.md

@@ -1,43 +1,62 @@
 ## 0.9.0 (edge)
 
-* A `console` wrapper has been added to the stdlib, requiring it will make available the `$console` global variable.
+*   A `console` wrapper has been added to the stdlib, requiring it will make available the `$console` global variable.
 
-* `Kernel#pp` no longer forwards arguments directly to `console.log`, this behavior has been replaced by stdlib's own `console.rb` (see above).
+*   `Kernel#pp` no longer forwards arguments directly to `console.log`, this behavior has been *   `replaced by stdlib's own `console.rb` (see above).
 
-* `method_added`, `method_removed` and `method_undefined` reflection now works.
+*   `method_added`, `method_removed` and `method_undefined` reflection now works.
 
-* `singleton_method_added`, `singleton_method_removed` and `singleton_method_undefined` reflection now works.
+*   `singleton_method_added`, `singleton_method_removed` and `singleton_method_undefined` reflection now works.
 
-* Now you can bridge a native class to a Ruby class that inherits from another Ruby class
+*   Now you can bridge a native class to a Ruby class that inherits from another Ruby class
 
-* `Numeric` semantics are now compliant with Ruby.
+*   `Numeric` semantics are now compliant with Ruby.
 
-* `Complex` has been fully implemented.
+*   `Complex` has been fully implemented.
 
-* `Rational` has been fully implemented.
+*   `Rational` has been fully implemented.
 
-* `Opal::Sprockets.javascript_include_tag` has been add to allow easy debug mode (i.e. with source maps) when including a sprockets asset into an HTML page.
+*   `Opal::Sprockets.javascript_include_tag` has been add to allow easy debug mode (i.e. with source maps) when including a sprockets asset into an HTML page.
 
-* `Opal::Processor.load_asset_code(sprockets, name)` has been deprecated in favor of `Opal::Sprockets.load_asset(name, sprockets)`.
+*   `Opal::Processor.load_asset_code(sprockets, name)` has been deprecated in favor of `Opal::Sprockets.load_asset(name, sprockets)`.
 
-* `Struct#hash` now works properly based on struct contents
+*   `Struct#hash` now works properly based on struct contents
 
-* No longer crashes when calling a method with an opt arg followed by an optional kwarg when called without the kwarg
+*   No longer crashes when calling a method with an opt arg followed by an optional kwarg when called without the kwarg
 
-* Newly compliant with RubySpec:
-  * `Enumerable#chunk`
+*   Newly compliant with RubySpec:
+    *   `Enumerable#chunk`
+    *   `Enumerable#each_cons`
+    *   `Enumerable#minmax`
+
+*   Operator methods (e.g. `+`, `<`, etc.) can be handled by `method_missing`
+
+*   `OpenStruct` - fixed `#method missing`, `#inspect`, `#to_s`, `#delete_field`. Fully compliant except for frozen and marshal behavior.
+
+*   Fix issue where passing a block after a parameter and a hash was causing block to not be passed (e.g. `method1 some_param, 'a' => 1, &block`)
+
+*   `Kernel#raise` now properly re-raises exceptions (regardless of how many levels deep you are) and works properly if supplied a class that has an exception method.
+
+*   `Exception#exception`, `Exception::exception`, `Exception#message`, and `Exception#to_s` are fully implemented
+
+*   Method defs issued inside `Module#instance_eval` and `Class#instance_eval`, and the respective `exec` now create class methods
+
+*   You can make direct JavaScript method calls on using the `recv.JS.method`syntax. Has support for method calls, final callback (as a block), property getter and setter (via `#[]` and `#[]=`), splats, JavaScript keywords (via the `::JS` module) and global functions (after `require "js"`).
+
+* `Set#superset?`, `Set#subset?`, and the respective 'proper_' variant of each are now implemented
+
+* Now with enabled arity checks calling a method with more arguments than those supported by its signature raises an `ArgumentError` as well.
 
-* Operator methods (e.g. `+`, `<`, etc.) can be handled by `method_missing`
+* `NameError` and `NoMethodError` - add `#name` and `#args` attributes
 
-* `OpenStruct` - fixed `#method missing`, `#inspect`, `#to_s`, `#delete_field`. Fully compliant except for frozen and marshal behavior.
+* Previously arity checks would raise an error without clearing the block for a method, the could lead to strange bugs in case the error was rescued.
 
-* Fix issue where passing a block after a parameter and a hash was causing block to not be passed (e.g. `method1 some_param, 'a' => 1, &block`)
+* `RegExp#match` now works correctly in multiline mode with white space
 
-* `Kernel#raise` now properly re-raises exceptions (regardless of how many levels deep you are) and works properly if supplied a class that has an exception method.
+* `Regexp#===` returns false when the right hand side of the expression cannot be coereced to a string (instead of throwing a TypeError)
 
-* `Exception#exception`, `Exception::exception`, `Exception#message`, and `Exception#to_s` are fully implemented
+* `Regexp#options` has been optimized and correctly returns 0 when called on a Regexp literal without any options (e.g. //)
 
-* Method defs issued inside `Module#instance_eval` and `Class#instance_eval`, and the respective `exec` now create class methods
 
 ## 0.8.1 2015-10-12
 

data/CONTRIBUTING.md

@@ -38,7 +38,7 @@ $ bundle install
 $ npm install -g jshint
 ```
 
-RubySpec related repos must be cloned as a git submodules:
+RubySpec related repos must be cloned as git submodules:
 
 ```
 $ git submodule update --init
@@ -58,22 +58,22 @@ You are now ready to make your first contribution to Opal! At a high level, your
 
 ## Down The Rabbit Hole
 
-Before making changes to Opal source, you need to understand a little about how the test suite works. Every spec that Opal test suite executes is listed in `spec/rubyspecs` file. Each line in that file is a path to either a spec file or a directory full of spec files. If it's a path to a directory, all spec files in that directory will be executed when you run the test suite. All paths are relative to the top-level `specs` directory. Let's follow one of these paths - `rubyspec/core/string/sub_spec` - and see where it goes.
+Before making changes to Opal source, you need to understand a little about how the test suite works. Every spec that Opal test suite executes is listed in `spec/rubyspecs` file. Each line in that file is a path to either a spec file or a directory full of spec files. If it's a path to a directory, all spec files in that directory will be executed when you run the test suite. Lines starting with a `!` represent files that are excluded (i.e. "execute all files in a given directory, *except* this file"), and lines starting with a `#` are ignored as comments. All paths are relative to the top-level `specs` directory. Let's follow one of these paths - `rubyspec/core/string/sub_spec` - and see where it goes.
 
-Navigating to `spec/rubyspec/core` directory, you see that it contains multiple sub-directories, usually named after the Ruby class or module. Drilling further down into `spec/rubyspec/core/string` you see all the spec files for the various `String` behaviors under test, usually named by a method name followed by `_spec.rb`. Opening `spec/rubyspec/core/string/sub_spec.rb` you finally see the code that checks the correctness of Opal's implementation of `String#sub` method's behavior.
+Navigating to `spec/rubyspec/core` directory, you see that it contains multiple sub-directories, usually named after the Ruby class or module. Drilling further down into `spec/rubyspec/core/string` you see all the spec files for the various `String` behaviors under test, usually named by a method name followed by `_spec.rb`. Opening `spec/rubyspec/core/string/sub_spec.rb` you finally see the code that checks the correctness of Opal's implementation of the `String#sub` method's behavior.
 
 When you execute `$ bundle exec rake`, the code in this file is executed, along with all the other specs in the entire test suite. It's a good idea to run the entire test suite when you feel you reached a certain milestone in the course of making your changes (exactly what that means is up to you), and definitely do `$ bundle exec rake` before commiting your changes to make sure they have not introduced regressions or other unintended side effects.
 
 But you will want to run tests as often as possible, after every small change, and running the entire test suite will slow you down. You need to be able to execute a single spec that is concerned with the feature you are currently working on. To accomplish this, just add `PATTERN` to your spec invocation command, like this:
 
 ```
-$ env PATTERN="spec/rubyspec/core/string/sub_spec.rb" bundle exec rake mspec_node
+$ bundle exec rake mspec_rubyspec_node PATTERN=spec/rubyspec/core/string/sub_spec.rb
 ```
 
 This will make sure that only `spec/rubyspec/core/string/sub_spec.rb` is run, and no other specs are executed. Globs can be used too:
 
 ```
-$ env PATTERN="spec/rubyspec/core/string/*_spec.rb" bundle exec rake mspec_node
+$ bundle exec rake mspec_rubyspec_node PATTERN=spec/rubyspec/core/string/*_spec.rb
 ```
 
 Another way to quickly validate ideas and play with your changes is to use `opal-repl`, a tool similar to `irb`. Running `opal-repl` drops you into an interactive environment with your current version of Opal loaded, including any changes you have made.
@@ -168,17 +168,9 @@ If I were to continue running benchmarks, more columns would be added to the rep
 This type of benchmarking relies on a feature of MSpec whereby you can ask it to execute every example in a given spec multiple times. Adding `BM=<number of times>` to your regular spec suite invocation command will hook into this MSpec functionality, collect timing information, and dump the results into the benchmarking workspace, making them available for reporting. Below is an example run with a single spec and `BM` set to `100`, meaning each example in the spec would be run 100 times.
 
 ```
-$ bundle exec rake mspec_node PATTERN=spec/rubyspec/core/array/permutation_spec.rb BM=100
-[44, :filters]
-[1, :custom]
-mkdir -p tmp
-mkdir -p tmp/bench
-ruby -rbundler/setup -rmspec/opal/special_calls bin/opal -gmspec -Ispec -Ilib -smspec/helpers/tmp -smspec/helpers/environment -smspec/guards/block_device -smspec/guards/endian -rnodejs/io -rnodejs/kernel -Dwarning -A tmp/mspec_node.rb -c > tmp/mspec_node.js
-jshint --verbose tmp/mspec_node.js
-NODE_PATH=stdlib/nodejs/node_modules node tmp/mspec_node.js
-................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
-Finished
-1200 examples, 0 failures (time taken: 0.7880001068115234)
+$ bundle exec rake mspec_rubyspec_node PATTERN=spec/rubyspec/core/array/permutation_spec.rb BM=100
+
+...
 
 Benchmark results have been written to tmp/bench/Spec1
 To view the results, run bundle exec rake bench:report

data/lib/opal/compiler.rb

@@ -318,6 +318,11 @@ module Opal
       return returns s(:nil) unless sexp
 
       case sexp.type
+      # Undefs go from 1 ruby undef a,b,c to multiple JS Opal.udef() calls, so need to treat them as individual statements
+      # and put the return on the last one 
+      when :undef
+        last = sexp.pop
+        sexp << returns(last)
       when :break, :next, :redo
         sexp
       when :yield

data/lib/opal/nodes/def.rb

@@ -80,9 +80,10 @@ module Opal
           end
 
           unshift "\n#{current_indent}", scope.to_vars
-          line stmt_code
 
-          unshift arity_code if arity_code
+          line arity_code if arity_code
+
+          line stmt_code
 
           unshift "var $zuper = $slice.call(arguments, 0);" if scope.uses_zuper
 
@@ -243,7 +244,13 @@ module Opal
         aritycode = "var $arity = arguments.length;"
 
         if arity < 0 # splat or opt args
-          aritycode + "if ($arity < #{-(arity + 1)}) { Opal.ac($arity, #{arity}, this, #{meth}); }"
+          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)
+          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}); }"
         end

data/lib/opal/nodes/definitions.rb

@@ -16,10 +16,21 @@ module Opal
     class UndefNode < Base
       handle :undef
 
-      children :mid
-
       def compile
-        push "Opal.udef(self, '$#{mid[1].to_s}');"
+        children.each do |child|
+          value = child[1]
+          statements = []
+          if child[0] == :js_return
+             value = value[1]
+             statements << expr(s(:js_return))
+          end
+          statements << "Opal.udef(self, '$#{value.to_s}');"
+          if children.length > 1 && child != children.first
+            line *statements
+          else
+            push *statements
+          end
+        end
       end
     end
 

data/lib/opal/paths.rb

@@ -18,15 +18,25 @@ module Opal
   def self.append_path(path)
     append_paths(path)
   end
+
+  # Same as #append_path but can take multiple paths.
   def self.append_paths(*paths)
-    self.paths.concat(paths)
+    @paths.concat(paths)
+    nil
   end
 
   module UseGem
+    # Adds the "require_paths" (usually `lib/`) of gem with the given name to
+    # Opal paths. By default will include the "require_paths" from all the
+    # dependent gems.
+    #
+    # @param gem_name [String] the name of the gem
+    # @param include_dependencies [Boolean] whether or not to add recursively
+    #   the gem's dependencies
     def use_gem(gem_name, include_dependencies = true)
       append_paths(*require_paths_for_gem(gem_name, include_dependencies))
     end
-    
+
     private
 
     def require_paths_for_gem(gem_name, include_dependencies)
@@ -48,8 +58,15 @@ module Opal
 
   extend UseGem
 
-  # Private, don't add to these directly (use .append_path instead).
   def self.paths
-    @paths ||= [core_dir.untaint, std_dir.untaint, gem_dir.untaint]
+    @paths.dup.freeze
   end
+
+  # Resets Opal.paths to the default value (includes `corelib`, `stdlib`, `opal/lib`)
+  def self.reset_paths!
+    @paths = [core_dir.untaint, std_dir.untaint, gem_dir.untaint]
+    nil
+  end
+
+  reset_paths!
 end

data/lib/opal/version.rb

@@ -1,5 +1,5 @@
 module Opal
   # WHEN RELEASING:
   # Remember to update RUBY_ENGINE_VERSION in opal/corelib/constants.rb too!
-  VERSION = '0.9.0.beta1'
+  VERSION = '0.9.0.beta2'
 end

data/opal/corelib/array.rb

@@ -1262,7 +1262,7 @@ class Array < `Array`
           }
         }
 
-        #{raise NoMethodError, "#{Opal.inspect(`item`)} doesn't respond to #to_str, #to_ary or #to_s"};
+        #{raise NoMethodError.new("#{Opal.inspect(`item`)} doesn't respond to #to_str, #to_ary or #to_s", 'to_str')};
       }
 
       if (sep === nil) {

data/opal/corelib/basic_object.rb

@@ -52,12 +52,12 @@ class BasicObject
           result;
 
       block.$$s = null;
-      
+
       // need to pass $$eval so that method definitions know if this is being done on a class/module. Cannot be compiler driven since
       // send(:instance_eval) needs to work
       if (self.$$is_class || self.$$is_module) {
         self.$$eval = true;
-        try {          
+        try {
           result = block.call(self, self);
         }
         finally {
@@ -67,7 +67,7 @@ class BasicObject
       else {
         result = block.call(self, self);
       }
-      
+
       block.$$s = old;
 
       return result;
@@ -80,17 +80,17 @@ class BasicObject
     %x{
       var block_self = block.$$s,
           result;
-          
+
       block.$$s = null;
-      
+
       if (self.$$is_class || self.$$is_module) {
         self.$$eval = true;
-        try {        
+        try {
           result = block.apply(self, args);
         }
         finally {
           self.$$eval = false;
-        }        
+        }
       }
       else {
         result = block.apply(self, args);
@@ -112,8 +112,8 @@ class BasicObject
   end
 
   def method_missing(symbol, *args, &block)
-    Kernel.raise NoMethodError, `self.$inspect && !self.$inspect.$$stub` ?
+    Kernel.raise NoMethodError.new(`self.$inspect && !self.$inspect.$$stub` ?
       "undefined method `#{symbol}' for #{inspect}:#{`self.$$class`}" :
-      "undefined method `#{symbol}' for #{`self.$$class`}"
+      "undefined method `#{symbol}' for #{`self.$$class`}", symbol)
   end
 end

data/opal/corelib/constants.rb

@@ -1,8 +1,8 @@
 RUBY_PLATFORM       = 'opal'
 RUBY_ENGINE         = 'opal'
 RUBY_VERSION        = '2.1.5'
-RUBY_ENGINE_VERSION = '0.9.0.beta1'
-RUBY_RELEASE_DATE   = '2015-10-19'
+RUBY_ENGINE_VERSION = '0.9.0.beta2'
+RUBY_RELEASE_DATE   = '2015-11-06'
 RUBY_PATCHLEVEL     = 0
 RUBY_REVISION       = 0
 RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2015 Adam Beynon'

data/opal/corelib/enumerable.rb

@@ -341,7 +341,52 @@ module Enumerable
   end
 
   def each_cons(n, &block)
-    raise NotImplementedError
+    if `arguments.length != 1`
+      raise ArgumentError, "wrong number of arguments (#{`arguments.length`} for 1)"
+    end
+
+    n = Opal.try_convert n, Integer, :to_int
+
+    if `n <= 0`
+      raise ArgumentError, 'invalid size'
+    end
+
+    unless block_given?
+      return enum_for(:each_cons, n) {
+        enum_size = self.enumerator_size
+        if enum_size.nil?
+          nil
+        elsif enum_size == 0 || enum_size < n
+          0
+        else
+          enum_size - n + 1
+        end
+      }
+    end
+
+    %x{
+      var buffer = [], result = nil;
+
+      self.$each.$$p = function() {
+        var element = #{Opal.destructure(`arguments`)};
+        buffer.push(element);
+        if (buffer.length > n) {
+          buffer.shift();
+        }
+        if (buffer.length == n) {
+          var value = Opal.yield1(block, buffer.slice(0, n));
+
+          if (value == $breaker) {
+            result = $breaker.$v;
+            return $breaker;
+          }
+        }
+      }
+
+      self.$each();
+
+      return result;
+    }
   end
 
   def each_entry(&block)
@@ -900,7 +945,39 @@ module Enumerable
   end
 
   def minmax(&block)
-    raise NotImplementedError
+    block ||= proc { |a,b| a <=> b }
+
+    %x{
+      var min = nil, max = nil, first_time = true;
+
+      self.$each.$$p = function() {
+        var element = #{Opal.destructure(`arguments`)};
+        if (first_time) {
+          min = max = element;
+          first_time = false;
+        } else {
+          var min_cmp = #{block.call(`min`, `element`)};
+
+          if (min_cmp === nil) {
+            #{raise ArgumentError, 'comparison failed'}
+          } else if (min_cmp > 0) {
+            min = element;
+          }
+
+          var max_cmp = #{block.call(`max`, `element`)};
+
+          if (max_cmp === nil) {
+            #{raise ArgumentError, 'comparison failed'}
+          } else if (max_cmp < 0) {
+            max = element;
+          }
+        }
+      }
+
+      self.$each();
+
+      return [min, max];
+    }
   end
 
   def minmax_by(&block)