opal 0.8.1 → 0.9.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee5e9d9c86a2c36d1a5c7b19bac3611ac4f4cac7
-  data.tar.gz: 1067110e4a386c8f6fb9a3cfd015ff22e8333edf
+  metadata.gz: 1af59805d32671acdce95d17776362c714d82c6d
+  data.tar.gz: cbe41468214bfdd99902f85301182b37a4281a8a
 SHA512:
-  metadata.gz: 5bccdee86e7e84447adecf51649c206794a4d17d3afb1ed29cf9f856825c5337ae46c1fefe3edd1f83d6bc3cf91f1931c396c8483d6ce43514149f5bddaa8fe6
-  data.tar.gz: a24da3eb375260399cd35b4cf237ce2ae836964b2c5357c3e8d1c8934a40d1735c4a4ed8c54a55b92db425a1286547ef2bcd81332fe6585675c60e10362b4484
+  metadata.gz: 280f8bc25e11405068eb0794bc3c094885f2b43266b9dfa8716e1f25009118a5c0556ed8b8d489f1f406cc862817753fb70065eda5e744c3f2f0de142607611b
+  data.tar.gz: d4ad1d81debb785c025807f6d18281dd191df37efef3afb2d548e611aa36ecb44bbe43846a8fe900f03cec73ec1be0159483d3c18f373eda3beda498bb16aa2b

data/.gitignore

@@ -13,5 +13,5 @@ build/
 .ruby-version
 .rvmrc
 
-# Ignore the rubyspec dir from recent releases (0.9+)
-/spec/rubyspec
+# Ignore the location of the older (0.8 and below) rubyspec submodule location
+spec/corelib

data/.gitmodules

@@ -1,6 +1,6 @@
-[submodule "spec/corelib"]
-	path = spec/corelib
-	url = https://github.com/opal/rubyspec
+[submodule "spec/rubyspec"]
+	path = spec/rubyspec
+	url = https://github.com/ruby/rubyspec.git
 [submodule "test/cruby"]
 	path = test/cruby
 	url = https://github.com/ruby/ruby.git

data/.jshintrc

@@ -5,9 +5,8 @@
   "eqeqeq"        : true, // Prohibit the use of == and != in favor of === and !==
   "es3"           : true, // Adhere to ECMAScript 3 specification
   "forin"         : true, // Require all for in loops to filter object's items (hasOwnProperty)
-  "latedef"       : true, // Prohibit the use of a variable before it was defined
+  "latedef"       : "nofunc", // Prohibit the use of a variable before it was defined (allow function declarations to be ignored)
   "noarg"         : true, // Prohibit the use of arguments.caller and arguments.callee
-  "nonbsp"        : true, // Warn about "non-breaking whitespace" characters
   "undef"         : true, // Prohibit the use of explicitly undeclared variables
   "unused"        : true, // Warn when you define and never use your variables
 
@@ -15,7 +14,8 @@
     "Opal": true,
     "OpalNode": true,
     "callPhantom": true,
-    "JSON": true
+    "JSON": true,
+    "Pippo": true
   },
 
   "browser": true,
@@ -23,29 +23,26 @@
 
   // Currently the following checks are failing:
 
-  "-W003": false, // 'variable' was used before it was defined
-  "-W004": false, // 'variable' is already defined
-  "-W018": false, // Confusing use of '!'
+  // To investigate:
+  "-W053": false, // Do not use String as a constructor
+  "-W069": false, // ['prop'] is better written in dot notation
+  "-W089": false, // The body of a for in should be wrapped in an if statement to filter unwanted properties from the prototype
+
+  // Compiler:
   "-W021": false, // '$ClassName' is a function
-  "-W024": false, // Expected an identifier and instead saw 'eval' (a reserved word)
   "-W027": false, // Unreachable ';' after 'return'
-  "-W032": false, // Unnecessary semicolon
   "-W030": false, // Expected an assignment or function call and instead saw an expression
+  "-W032": false, // Unnecessary semicolon
   "-W033": false, // Missing semicolon
-  "-W038": false, // 'variable' used out of scope
-  "-W041": false, // Use '===' to compare with 'true'
-  "-W049": false, // Unexpected escaped character '<' in regular expression
-  "-W053": false, // Do not use String as a constructor
-  "-W058": false, // Missing '()' invoking a constructor
-  "-W061": false, // eval can be harmful
-  "-W065": false, // Missing radix parameter
-  "-W069": false, // ['prop'] is better written in dot notation
-  "-W080": false, // It's not necessary to initialize 'result' to 'undefined'
+  "-W067": false, // Bad invocation
   "-W083": false, // Don't make functions within a loop
-  "-W086": false, // Expected a 'break' statement before 'case'
-  "-W089": false, // The body of a for in should be wrapped in an if statement to filter unwanted properties from the prototype
   "-W093": false, // Did you mean to return a conditional instead of an assignment?
   "-W098": false, // 'variable' is defined but never used
   "-W116": false, // Expected '===' and instead saw '=='
-  "-W120": false  // You might be leaking a variable ($ClassName) here
+  "-W120": false, // You might be leaking a variable ($ClassName) here
+
+  // Keeping these:
+  "-W061": false, // eval can be harmful
+  "-W086": false, // Expected a 'break' statement before 'case'
+  "-W100": false  // This character may get silently deleted by one or more browsers
 }

data/.travis.yml

@@ -5,8 +5,6 @@ sudo: false
 cache:
   bundler: true
   directories:
-    - test/cruby
-    - spec/corelib
     - /home/travis/.nvm/
 
 matrix:
@@ -14,7 +12,19 @@ matrix:
 
   include:
     - rvm: 2.2
-      env: RUN=default TZ="/usr/share/zoneinfo/Pacific/Fiji"
+      env: RUN=jshint SUITE=core
+
+    - rvm: 2.2
+      env: RUN=jshint SUITE=stdlib
+
+    - rvm: 2.2
+      env: RUN=mspec_opal_node
+
+    - rvm: 2.2
+      env: RUN=mspec_rubyspec_node TZ="/usr/share/zoneinfo/Pacific/Fiji"
+
+    - rvm: 2.2.3
+      env: RUN=mspec_rubyspec_phantom
 
     - rvm: 2.2
       env: RUN=rspec TILT_VERSION=2.0.1
@@ -22,12 +32,12 @@ matrix:
     - rvm: 2.1
       env: RUN=rspec
 
+    - rvm: 2.0
+      env: RUN="rspec"
+
     - rvm: 1.9.3
       env: RUN=rspec
 
-    - rvm: 2.0.0
-      env: RUN="rspec mspec_phantom"
-
     - rvm: rbx
       env: RUN=rspec
 
@@ -37,14 +47,13 @@ matrix:
     - rvm: jruby-head
       env: RUN=rspec
 
+  allow_failures:
     - rvm: 2.2
-      script:
-        - npm install -g jshint
-        - bundle exec rake lint
+      env: RUN=jshint SUITE=stdlib
 
-  allow_failures:
-    - rvm: 1.8.7
     - rvm: 1.9.3
+    - rvm: 2.1
+    - rvm: 2.0
     - rvm: rbx
     - rvm: jruby
     - rvm: jruby-head
@@ -55,6 +64,8 @@ before_install:
   - node -v
   - phantomjs -v
   - git submodule update --init
+  - npm install -g jshint
+  - npm install -g uglify-js
 
 script:
   - "bundle exec rake $RUN"

data/CHANGELOG.md

@@ -1,3 +1,44 @@
+## 0.9.0 (edge)
+
+* 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).
+
+* `method_added`, `method_removed` and `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
+
+* `Numeric` semantics are now compliant with Ruby.
+
+* `Complex` 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::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
+
+* 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`
+
+* 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
+
 ## 0.8.1 2015-10-12
 
 *   Use official Sprockets processor cache keys API:
@@ -7,7 +48,6 @@
 
 *   Fix an issue for which a Pathname was passed instead of a String to Sprockets.
 
-
 ## 0.8.0 2015-07-16
 
 *   Update to Sprockets v3.0.
@@ -20,6 +60,16 @@
 
 *   Fix `Promise#always`.
 
+*   Update to Sprockets v3.0.
+
+*   Delegate dependency management directly to Sprockets (when used) making sourcemaps swift again.
+    This means code generated by sprockets will always need to be bootstrapped via `Opal.load` or `Opal.require`.
+    Luckily `Opal::Processor.load_asset_code(sprockets, name)` does just that in the right way.
+
+*   Enable operator inlining by default in the compiler.
+
+*   Fix `Promise#always`.
+
 *   Fix `String#split` when no match is found and a limit is provided
 
 *   Fix `require_tree(".")` when used from file at the root of the assets paths

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,15 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of overtly sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces where an individual explicitly associates their presence with the project; non-project related material on accounts explicitly marked as personal should not be considered to be so associated.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/CONTRIBUTING.md

@@ -6,7 +6,7 @@ using opal (or related libraries) then use the
 [#opal](http://webchat.freenode.net/?channels=opal) irc channel on
 FreeNode.
 
-## Contributing
+## Contributing (TL;DR)
 
 1. Before opening a new issue, search for previous discussions including closed
 ones. Add comments there if a similar issue is found.
@@ -15,8 +15,13 @@ ones. Add comments there if a similar issue is found.
 
 3. Before sending pull requests make sure all tests run and pass (see below).
 
-4. Make sure to use a similar coding style to the rest of the code base. In ruby
-and javascript code we use 2 spaces (no tabs).
+4. Make sure to use a similar coding style to the rest of the code base. In Ruby
+and JavaScript code we use 2 spaces (no tabs).
+
+5. Make sure to have updated all the relevant documentation, both for API and
+the guides.
+
+If unsure about having satisfied any of the above points ask in the [Gitter channel](https://gitter.im/opal/opal) or just open the issue/pull-request asking for help. There's a good chance someone will help you through the necessary steps.
 
 ## Quick Start
 
@@ -30,6 +35,7 @@ Get dependencies:
 
 ```
 $ bundle install
+$ npm install -g jshint
 ```
 
 RubySpec related repos must be cloned as a git submodules:
@@ -52,24 +58,31 @@ 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 - `corelib/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. 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/corelib/core` directory, you see that it contains multiple sub-directories, usually named after the Ruby class or module. Drilling further down into `spec/corelib/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/corelib/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 `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:
+
 ```
-$ bundle exec rake mspec_node PATTERN=spec/corelib/core/string/sub_spec.rb
+$ env PATTERN="spec/rubyspec/core/string/sub_spec.rb" bundle exec rake mspec_node
+```
+
+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
 ```
-This will make sure that only `spec/corelib/core/string/sub_spec.rb` is run, and no other specs are executed.
 
 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.
+
 ```
 $ bundle exec opal-repl
 >> 2 + 2
 => 4
->> 
+>>
 ```
 
 When quickly iterating on an idea, even `opal-repl` may feel a bit too heavy, because after making a change in Opal, you must `exit` from `opal-repl` and do `$ bundle exec opal-repl` again to load Opal with your latest changes. In this case, you can run `opal` with the `-e` option, which executes a piece of code you pass to it once, then returns to the shell. This means that in order to run it again after making another adjustment to Opal, all you have to do is hit the up arrow key on your keyboard and press the enter key. This is the fastest way to go from making a change in Opal to seeing its effect.
@@ -81,8 +94,111 @@ hello
 $
 ```
 
-Let's recap what we covered so far. `spec/rubyspecs` is the "master list" of all the specs that get executed when you do `$ bundle exec rake`. You know where to find individual specs, inspect them, and execute them selectively or in bulk. But how do you know which specs to work on? You may be tempted to compare the contents of one of the directories in `spec/corelib/core` with the list of paths in `spec/rubyspecs`, add the missing paths to the "master list", run `$ bundle exec rake`, and start fixing the failures by implementing the missing features. However, chances are that as you are reading this, there are plenty of failing tests in the specs that are already listed in `spec/rubyspecs`. How can that be if `$ bundle exec rake` runs green? To understand this, you need to get acquainted with the concept of spec filters.
+Let's recap what we covered so far. `spec/rubyspecs` is the "master list" of all the specs that get executed when you do `$ bundle exec rake`. You know where to find individual specs, inspect them, and execute them selectively or in bulk. But how do you know which specs to work on? You may be tempted to compare the contents of one of the directories in `spec/rubyspec/core` with the list of paths in `spec/rubyspecs`, add the missing paths to the "master list", run `$ bundle exec rake`, and start fixing the failures by implementing the missing features. However, chances are that as you are reading this, there are plenty of failing tests in the specs that are already listed in `spec/rubyspecs`. How can that be if `$ bundle exec rake` runs green? To understand this, you need to get acquainted with the concept of spec filters.
 
 There are two types of spec filters in the Opal project: `spec/filters/bugs` and `spec/filters/unsupported`. Both filters have the same effect: any spec failures that are noted inside any of the files inside of these directories are ignored when running the spec suite, i.e. they are not reported as failures. Even though their effect is the same, the purpose of `bugs` and `unsupported` filters is different. As the name suggests, `unsupported` filters list _permanent_ failures, things that other Ruby implementations can do that Opal cannot and will never be able to do (by design and by virtue of being implemented on top of JavaScript running in the browser environment). `bugs` filters, on the other hand, are _temporary_ failures, problems that need to be worked on. Problems that Opal needs your help with. Think of the `bugs` directory and the files contained within it as your "TO DO" list for contributing to Opal.
 
 Comment out any of the `fail` lines in any of the files in the `spec/filters/bugs` directory, run `$bundle exec rake`, and watch it fail. Make it pass and submit a pull request - that's all there is to it :) Happy hacking!
+
+## Benchmarking
+
+There are two ways to benchmark Opal's performance: one way is to write a program (or a set of programs) that takes sufficently long time to execute, then measure the execution time, and the other is to execute a specific RubySpec example (or a set of examples) multiple times, then measure the execution time. Let's call the former "traditional benchmarking", and the latter "RubySpec benchmarking".
+
+Regardless of which of the two types of benchmarking above you happen to be doing, the reporting of benchmark results works the same way: `bundle exec rake bench:report`.
+
+It's important to understand that benchmarking in Opal works on the principle of a single, shared benchmarking workspace, a *bench*, where the results of each benchmark run that you perform get automatically saved. When you do `bundle exec rake bench:report`, you get a combined report of all of the benchmark results that are currently sitting in your workspace. This means you can check out an older commit, run benchmarks, checkout a newer commit, run benchmarks, then run the report to see the results from the two commits side-by-side. After you're done, (or before starting a new benchmarking session), you can do `bundle exec rake bench:clear` to reset your workspace to a clean slate.
+
+You can get a list of all the available benchmarking commands by running `bundle exec rake -T | grep bench` as shown below.
+```
+$ bundle exec rake -T | grep bench
+
+rake bench:clear            # Delete all benchmark results
+rake bench:opal             # Benchmark Opal
+rake bench:report           # Combined report of all benchmark results
+rake bench:ruby             # Benchmark Ruby
+```
+
+### Traditional Benchmarking
+
+At the root of the opal project tree is a folder called `benchmark` that contains a file called `benchmarks`. This file lists all of the benchmarks that will be run if you do `bundle exec bench:opal` without specifying any particular benchmark file(s) as parameters to this rake task. In the example below, I pick which benchmarks to run by passing their file paths as parameters to the rake task.
+
+Start with a clean slate:
+```
+$ bundle exec rake bench:clear
+
+rm tmp/bench/*
+```
+
+Run two benchmark programs from the MRI benchmarking suite by passing their file paths as parameters:
+(Note: passing params to Rake tasks is tricky - notice there is no space after the comma!)
+```
+$ bundle exec rake bench:opal[test/cruby/benchmark/bm_app_answer.rb,test/cruby/benchmark/bm_app_factorial.rb]
+
+bundle exec opal benchmark/run.rb test/cruby/benchmark/bm_app_answer.rb test/cruby/benchmark/bm_app_factorial.rb | tee tmp/bench/Opal1
+test/cruby/benchmark/bm_app_answer.rb    0.7710001468658447
+test/cruby/benchmark/bm_app_factorial.rb 0.0820000171661377
+===============================================
+Executed 2 benchmarks in 0.8530001640319824 sec
+```
+
+In this case, I want to see how Opal's results stack up against MRI's results, so I will run the same set of benchmarks for Ruby:
+```
+$ bundle exec rake bench:ruby[test/cruby/benchmark/bm_app_answer.rb,test/cruby/benchmark/bm_app_factorial.rb]
+
+bundle exec ruby benchmark/run.rb test/cruby/benchmark/bm_app_answer.rb test/cruby/benchmark/bm_app_factorial.rb | tee tmp/bench/Ruby1
+test/cruby/benchmark/bm_app_answer.rb    0.04913724200014258
+test/cruby/benchmark/bm_app_factorial.rb 1.3288652799965348
+===============================================
+Executed 2 benchmarks in 1.3780025219966774 sec
+```
+
+Now I'm ready to see the result of the two runs side-by-side:
+```
+$ bundle exec rake bench:report
+
+Benchmark                                 Opal1  Ruby1
+test/cruby/benchmark/bm_app_answer.rb     0.771  0.049
+test/cruby/benchmark/bm_app_factorial.rb  0.082  1.329
+```
+
+If I were to continue running benchmarks, more columns would be added to the report. You can select which columns you want to display (and in what order) by passing their names as params to the rake task like so: `bundle exec rake bench:report[Ruby1,Opal1]`
+
+### RubySpec Benchmarking
+
+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)
+
+Benchmark results have been written to tmp/bench/Spec1
+To view the results, run bundle exec rake bench:report
+```
+
+Now let's see the report:
+(Spec names can be very long, scroll to the right to see the numbers)
+```
+$ bundle exec rake bench:report
+Benchmark                                                                                                                     Spec1
+Array#permutation_returns_an_Enumerator_of_all_permutations_when_called_without_a_block_or_arguments                          0.117
+Array#permutation_returns_an_Enumerator_of_permutations_of_given_length_when_called_with_an_argument_but_no_block             0.064
+Array#permutation_yields_all_permutations_to_the_block_then_returns_self_when_called_with_block_but_no_arguments              0.076
+Array#permutation_yields_all_permutations_of_given_length_to_the_block_then_returns_self_when_called_with_block_and_argument  0.072
+Array#permutation_returns_the_empty_permutation_([[]])_when_the_given_length_is_0                                             0.029
+Array#permutation_returns_the_empty_permutation([])_when_called_on_an_empty_Array                                             0.029
+Array#permutation_returns_no_permutations_when_the_given_length_has_no_permutations                                           0.029
+Array#permutation_handles_duplicate_elements_correctly                                                                        0.081
+Array#permutation_handles_nested_Arrays_correctly                                                                             0.085
+Array#permutation_truncates_Float_arguments                                                                                   0.063
+Array#permutation_returns_an_Enumerator_which_works_as_expected_even_when_the_array_was_modified                              0.056
+Array#permutation_generates_from_a_defensive_copy,_ignoring_mutations                                                         0.038
+```

data/Gemfile

@@ -23,4 +23,4 @@ unless ENV['CI']
   gem 'terminal-notifier-guard'
 end
 
-gem 'mspec', github: 'rubyspec/mspec'
+gem 'mspec', github: 'ruby/mspec'

data/Guardfile

@@ -51,10 +51,10 @@ class ::Guard::Opal < Plugin
     case path
     when %r{grammar\.y$}  then system 'rake racc'
     when %r{^spec/lib}     then rspec path
-    when %r{^spec/corelib} then mspec path
+    when %r{^spec/rubyspec} then mspec path
     when %r{^opal/corelib}
       name = File.basename(path, '.rb')
-      mspec "spec/corelib/core/#{name}/**/*_spec.rb"
+      mspec "spec/rubyspec/core/#{name}/**/*_spec.rb"
     when %r{^lib/opal/(.*)\.rb$}
       name = $1
       specs = Dir["spec/lib/#{name}_spec.rb"]