opal 0.10.0 → 0.11.0

data/benchmark-ips/bm_constants_lookup.rb

@@ -0,0 +1,13 @@
+module A
+  module B
+    module C
+      Benchmark.ips do |x|
+        x.report("Kernel") { Kernel }
+        x.report("::Kernel") { ::Kernel }
+        x.report("B") { B }
+        x.report("B::C") { B::C }
+        x.compare!
+      end
+    end
+  end
+end

data/benchmark-ips/bm_is_number.rb

@@ -0,0 +1,29 @@
+# Why .$$is_number is better than isNaN:
+#
+#
+# Warming up --------------------------------------
+#         .$$is_number   106.722k i/100ms
+#              isNaN()   105.040k i/100ms
+#      obj.$$is_number   106.864k i/100ms
+#           isNaN(obj)    89.287k i/100ms
+# Calculating -------------------------------------
+#         .$$is_number     12.052M (± 6.6%) i/s -     59.978M in   5.002614s
+#              isNaN()     12.338M (± 5.4%) i/s -     61.448M in   4.997957s
+#      obj.$$is_number     12.514M (± 6.8%) i/s -     62.302M in   5.005715s
+#           isNaN(obj)      4.211M (± 5.9%) i/s -     20.982M in   5.001643s
+#
+# Comparison:
+#      obj.$$is_number: 12513664.2 i/s
+#              isNaN(): 12338259.3 i/s - same-ish: difference falls within error
+#         .$$is_number: 12051756.8 i/s - same-ish: difference falls within error
+#           isNaN(obj):  4211175.7 i/s - 2.97x  slower
+#
+Benchmark.ips do |x|
+  number = 123
+  number_obj = 123.itself
+  x.report(".$$is_number")    { number.JS['$$is_number'] }
+  x.report("isNaN()")         { `!isNaN(number)` }
+  x.report("obj.$$is_number") { number_obj.JS['$$is_number'] }
+  x.report("isNaN(obj)")      { `!isNaN(number_obj)` }
+  x.compare!
+end

data/benchmark-ips/bm_symbol_to_proc.rb

@@ -0,0 +1,19 @@
+# https://github.com/opal/opal/issues/1659#issuecomment-298222232
+
+Benchmark.ips do |x|
+  a = []
+
+  50.times do |i|
+    a << %(#{i}\n)
+  end
+
+  x.report('map block') do
+    a.map {|it| it.chomp }
+  end
+
+  x.report('map symbol') do
+    a.map(&:chomp)
+  end
+
+  x.compare!
+end

data/bin

@@ -0,0 +1 @@
+./exe

data/docs/compiled_ruby.md

@@ -38,7 +38,7 @@ and `FalseClass` classes from ruby.
 ```ruby
 "hello world!"    # => "hello world!"
 :foo              # => "foo"
-<<-EOS            # => "\nHello there.\n"
+<<-EOS            # => "Hello there.\n"
 Hello there.
 EOS
 ```
@@ -119,11 +119,12 @@ end
 This would be compiled into:
 
 ```javascript
-var val = 42;
-
-if (val !== false && val !== nil) {
-  return 3.142;
-}
+val = 42;
+if (val !== false && val !== nil && val != null) {
+  return 3.142
+} else {
+  return nil
+};
 ```
 
 This makes the generated truthy tests (`if` statements, `and` checks and
@@ -162,9 +163,9 @@ of JavaScript code that is wrapped inside an anonymous function. This
 looks similar to the following:
 
 ```javascript
-(function($opal) {
-  var $klass = $opal.klass, self = $opal.top;
-  // generated code
+(function(Opal) {
+  // some setup code code
+  return self.$puts("foo")
 })(Opal);
 ```
 
@@ -177,14 +178,15 @@ puts "foo"
 This would compile directly into:
 
 ```javascript
-(function($opal) {
-  var $klass = $opal.klass, self = $opal.top;
-  self.$puts("foo");
+(function(Opal) {
+  var self = Opal.top, $nesting = [], nil = Opal.nil, $breaker = Opal.breaker, $slice = Opal.slice;
+
+  Opal.add_stubs(['$puts']);
+  return self.$puts("foo")
 })(Opal);
 ```
 
-Most of the helpers are no longer present as they are not used in this
-example.
+**TIP:** you can see the compiled code with this command: `opal --compile --no-exit --no-opal --eval 'puts "foo"'`
 
 ### Using compiled sources
 

data/docs/faq.md

@@ -2,11 +2,11 @@
 
 ### Why does Opal exist?
 
-To try and keep ruby relevant in a world where client-side apps are making javascript the primary development platform.
+To try and keep ruby relevant in a world where client-side applications are making javascript the primary development platform.
 
 ### How compatible is Opal?
 
-We run opal against the [ruby spec](https://github.com/ruby/spec) as our primary testing setup. We try to make Opal as compatible as possible, whilst also taking into account restrictions of JavaScript when applicable. Opal supports the majority of ruby syntax features, as well as a very large part of the corelib implementation. We support method\_missing, modules, classes, instance\_exec, blocks, procs and lots lots more. Opal can compile and run Rspec unmodified, as well as self hosting the compiler at runtime.
+We run opal against the [ruby spec](https://github.com/ruby/spec) as our primary testing setup. We try to make Opal as compatible as possible, whilst also taking into account restrictions of JavaScript when applicable. Opal supports the majority of ruby syntax features, as well as a very large part of the corelib implementation. We support method\_missing, modules, classes, instance\_exec, blocks, procs and lots lots more. Opal can compile and run RSpec unmodified, as well as self hosting the compiler at runtime.
 
 ### What version of ruby does Opal target?
 
@@ -14,4 +14,4 @@ We are running tests under ruby 2.0.0 conditions, but are mostly compatible with
 
 ### Why doesn't Opal support mutable strings?
 
-All strings in Opal are immutable because ruby strings just get compiled direclty into javascript strings, which are immutable. Wrapping ruby strings as a custom JavaScript object would add a lot of overhead as well as making interaction between ruby and javascript libraries more difficult.
+All strings in Opal are immutable because ruby strings just get compiled directly into javascript strings, which are immutable. Wrapping ruby strings as a custom JavaScript object would add a lot of overhead as well as making interaction between ruby and javascript libraries more difficult.

data/docs/headless_chrome.md

@@ -0,0 +1,105 @@
+# Headless Chrome
+
+## Requirements
+
+First of all, make sure that you have Chrome at least 59.0 installed.
+Also for now it's supported only on Mac and Linux. (version 60 may get support on Windows)
+
+## Using the runner
+
+To run your code using headless chrome, use `-R chrome` (`--runner chrome`) option:
+
+    $ opal -Rchrome -e "puts 'Hello, Opal'"
+    Hello, Opal
+
+The runner also listens for any exceptions and prints formatted stracktraces back to your console:
+
+    $ opal -Rchrome -e "
+    def raising_method
+      raise 'test error'
+    end
+
+    raising_method
+    "
+
+    RuntimeError : test error
+        at $$raise (file:///tmp/chrome-opal.js:4996:6)
+        at $$raising_method (file:///tmp/chrome-opal.js:21144:16)
+        at  (file:///tmp/chrome-opal.js:21146:14)
+        at  (file:///tmp/chrome-opal.js:21147:2)
+
+## Using exit codes
+
+By default headless chrome runner explicitly sets exit code to 1 when there was any error in the code.
+
+    $ opal -Rchrome -e "42"; echo $?
+    0
+
+    $ opal -Rchrome -e "raise 'error'"; echo $?
+    RuntimeError : error
+        at $$raise (file:///tmp/chrome-opal.js:4996:6)
+        at  (file:///tmp/chrome-opal.js:21139:14)
+        at  (file:///tmp/chrome-opal.js:21140:2)
+    1
+
+You can change final exit code by using `Kernel#exit`, but make sure to require `opal/platform` in your code.
+
+    $ opal -Rchrome -ropal/platform -e "exit(0)"; echo $?
+    0
+
+    $ opal -Rchrome -ropal/platform -e "exit(1)"; echo $?
+    1
+
+Also `Kernel#exit` doesn't abort your script. It simply takes the value that was passed to the first
+invocation and persists it in `window.OPAL_EXIT_CODE`. Later headless chrome runner extracts it from the chrome runtime.
+
+## Known limitations
+
+1. `exit` doesn't abort you script (but `raise/throw` does)
+2. When you call `console.log(one, two, three)` from your code headless chrome prints only the first passed object.
+   The reason behind it is the format of the message that chrome sends to the runner.
+   Opal intentionally uses a simplified method from Chrome API (`Console.messageAdded`) to catch `console.log` invocations.
+   (Check `lib/opal/cli_runners/chrome.js` do get more information)
+
+## Internals
+
+Under the hood when you call `opal -Rchrome -e 'your code'` Opal uses chrome runner that is defined in
+`lib/opal/cli_runners/chrome.rb`. This runner tries to connect to `localhost:9222` (9222 is a default port for a headless chrome server)
+or runs the server on its own. It detects your platform and uses a default path to the chrome executable
+(`Opal::CliRunners::Chrome#chrome_executable`) but you can override it by specifying `GOOGLE_CHROME_BINARY` environment
+variable.
+
+When the server is up and running it passes compiled js code to `node lib/opal/cli_runners/chrome.js`
+as a plain input using stdin (basically, it's a second part of the runner).
+`chrome.js` is a node js script that does the main job. It runs any provided code on the running chrome server,
+catches errors and forwards console messages.
+
+
+Moreover, you can actually call any js using headless chrome by running
+
+      $ echo "console.log('Hello, Opal')" | node lib/opal/cli_runners/chrome.js
+
+NOTE: to run it you need to have a chrome server running on `localhost:9222` (usually `chrome.rb` does it for you)
+
+      $ chrome --disable-gpu --headless --remote-debugging-port=9222
+
+## Using a remote chrome server
+
+If you want to change a default chrome port or your chrome server is running on a different host:port
+you can override default values by specifying `CHROME_HOST` and `CHROME_PORT` environment variables:
+
+      $ CHROME_HOST=10.10.10.10 CHROME_PORT=8080 opal -Rchrome -e "puts 42"
+      Connecting to 10.10.10.10:8080...
+      42
+
+NOTE: `CHROME_HOST` requires a chrome server to be started. You can't start remotely a server on a different host.
+
+
+## Additional options
+
+If you need to pass additional CLI options to the Chrome executable you can do so by setting the `CHROME_OPTS` environment variable:
+
+      $ CHROME_OPS="--window-size=412,732" opal -Rchrome -e "puts 42"
+      42
+
+_For a list of additional options see https://developers.google.com/web/updates/2017/04/headless-chrome_

data/docs/rspec.md

@@ -1,8 +1,8 @@
 # RSpec
 
 `opal-rspec` allows opal to use rspec for running specs in javascript
-environments. It comes with built-in support for running rspec with custom
-`phantomjs` and standard web browser formatters. Also, async spec examples
+environments. It comes with built-in support for running rspec with
+standard web browser formatters. Also, async spec examples
 are supported to reflect browser usage of ruby applications.
 
 ```ruby
@@ -25,23 +25,6 @@ gem 'opal-rspec'
 
 ## Running specs
 
-### phantomjs
-
-To run specs, a rake task can be added which will load all spec files
-from `spec/`:
-
-```ruby
-# Rakefile
-require 'opal/rspec/rake_task'
-Opal::RSpec::RakeTask.new(:default)
-```
-
-Then, to run your specs inside phantomjs, just run the rake task:
-
-```sh
-$ bundle exec rake
-```
-
 ### In a Browser
 
 `opal-rspec` can use sprockets to build and serve specs over a simple rack server. Add the following to a `config.ru` file:
@@ -51,7 +34,8 @@ $ bundle exec rake
 require 'bundler'
 Bundler.require
 
-run Opal::Server.new { |s|
+sprockets_env = Opal::RSpec::SprocketsEnvironment.new
+run Opal::Server.new(sprockets: sprockets_env) { |s|
   s.main = 'opal/rspec/sprockets_runner'
   s.append_path 'spec'
   s.debug = false

data/docs/unsupported_features.md

@@ -6,6 +6,12 @@ Opal does not support some language/runtime features of ruby. These are document
 
 For performance and ease of runtime features, all strings in Opal are immutable, i.e. `#<<`, `#gsub!`, etc. do not exist. Also, symbols are just strings. There is no class, runtime or feature difference between Symbols and Strings. Their syntaxes can be used interchangeably.
 
+#### Integer / Float difference ####
+
+In Opal, both integers and floats belong to same class `Number` (using JavaScript native numbers). So `1 / 4` is `0.25` (not `0`) and `4.0 / 2` is `2` (not `2.0`).
+
+`Number` is a subclass of `Numeric`, like `Complex` and `Rational`.
+
 #### Encodings ####
 
 Encodings only have a very small implementation inside Opal.
@@ -18,10 +24,6 @@ JavaScript does not have a native `Thread` implementation, so they are not prese
 
 Opal does not currently support frozen objects, but has placeholder methods to prevent other libraries breaking when expecting these methods. Opal could support frozen objects in the future once a similar implementation becomes available across JavaScript runtimes.
 
-#### `method_added` and `method_removed` hooks ####
-
-These are not *currently* supported by Opal, but this is considered a bug and will be implemented soon.
-
 #### Private, Public and Protected methods ####
 
 All methods in Opal are defined as `public` to avoid additional runtime overhead. `Module#private` and `Module#protected` exist as just placeholder methods and are no-op methods.

data/examples/rack/Gemfile

@@ -1,3 +1,4 @@
 source 'https://rubygems.org'
 
+gem 'rack'
 gem 'opal', :path => '../../'

data/examples/rack/Gemfile.lock

@@ -1,24 +1,28 @@
 PATH
   remote: ../../
   specs:
-    opal (0.8.0.dev)
+    opal (0.11.0.dev)
+      ast (>= 2.3.0)
       hike (~> 1.2)
+      parser (>= 2.3.1.2)
       sourcemap (~> 0.1.0)
-      sprockets (>= 2.2.3, < 4.0.0)
-      tilt (~> 1.4)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    ast (2.3.0)
     hike (1.2.3)
-    rack (1.6.0)
+    parser (2.3.1.2)
+      ast (~> 2.2)
+    rack (2.0.1)
     sourcemap (0.1.1)
-    sprockets (3.0.3)
-      rack (~> 1.0)
-    tilt (1.4.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   opal!
+  rack
+
+BUNDLED WITH
+   1.12.5

data/examples/rack/app/application.rb

@@ -1,13 +1,24 @@
 require 'opal'
 require 'user'
+require 'opal/platform'
 
 module MyApp
   class Application
     def initialize
-      @user = User.new('Bill')
-      @user.authenticated?
+      @user = User.new('Bob')
+    end
+
+    def title
+      "#{@user.name} is #{:not unless @user.authenticated?} authenticated"
     end
   end
 end
 
-MyApp::Application.new
+$app = MyApp::Application.new
+
+require 'native'
+
+$$[:document][:title] = "#{$app.title}"
+
+bill = User.new('Bill')
+bill.authenticated?

data/examples/rack/app/user.rb

@@ -4,6 +4,8 @@ class User
     @name = name
   end
 
+  attr_reader :name
+
   def authenticated?
     if admin? or special_permission?
       true

data/examples/rack/config.ru

@@ -10,7 +10,7 @@ Bundler.require
 
 # with gems like opal-jquery or opal-browser you could manipulate the dom directly
 
-run Opal::Server.new { |s|
+run Opal::SimpleServer.new { |s|
   # the name of the ruby file to load. To use more files they must be required from here (see app)
   s.main = 'application'
   # the directory where the code is (add to opal load path )

data/examples/rack/index.html.erb

@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
   <head>
+    <meta charset="utf-8">
     <title>opal-sprockets demo</title>
 
     <%= javascript_include_tag 'application' %>

data/examples/sinatra/Gemfile

@@ -1,5 +1,5 @@
 source 'https://rubygems.org'
 
 gem 'opal', :path => '../..'
-gem 'thin' # webrick has a bug with safari
+gem 'puma' # webrick has a bug with safari
 gem 'sinatra'

data/examples/sinatra/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../..
   specs:
-    opal (0.9.0.dev)
+    opal (0.10.2)
       hike (~> 1.2)
       sourcemap (~> 0.1.0)
       sprockets (~> 3.1)
@@ -10,9 +10,9 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    daemons (1.2.2)
-    eventmachine (1.0.7)
+    concurrent-ruby (1.0.2)
     hike (1.2.3)
+    puma (3.6.0)
     rack (1.5.2)
     rack-protection (1.5.3)
       rack
@@ -21,12 +21,9 @@ GEM
       rack-protection (~> 1.4)
       tilt (~> 1.3, >= 1.3.4)
     sourcemap (0.1.1)
-    sprockets (3.3.3)
-      rack (~> 1.0)
-    thin (1.6.3)
-      daemons (~> 1.0, >= 1.0.9)
-      eventmachine (~> 1.0)
-      rack (~> 1.0)
+    sprockets (3.7.0)
+      concurrent-ruby (~> 1.0)
+      rack (> 1, < 3)
     tilt (1.4.1)
 
 PLATFORMS
@@ -34,8 +31,8 @@ PLATFORMS
 
 DEPENDENCIES
   opal!
+  puma
   sinatra
-  thin
 
 BUNDLED WITH
-   1.10.5
+   1.13.2

data/examples/sinatra/app/application.rb

@@ -2,6 +2,8 @@ require 'opal'
 
 def alert(msg)
   `alert(msg)`
+  raise "an example exception with source-map powered backtrace"
 end
 
 alert "Hi there!"
+

data/{bin → exe}/opal

@@ -12,11 +12,13 @@ rescue OptionParser::InvalidOption => e
 end
 
 require 'opal/cli'
-cli = Opal::CLI.new options.options.merge(
+options_hash = options.options
+options_hash.merge!(
   file:     ARGF.file,
   filename: ARGF.filename,
   argv:     ARGV.dup
-)
+) unless options_hash[:lib_only]
+cli = Opal::CLI.new options_hash
 
 begin
   cli.run

data/{bin → exe}/opal-repl

@@ -6,6 +6,8 @@ module Opal
   class V8Context
     def initialize
       @builder = Opal::Builder.new
+      @history_path = File.expand_path('~/.opal-repl-history')
+      @history = File.exist?(@history_path)
     end
 
     def run(filename = nil)
@@ -17,6 +19,13 @@ module Opal
         abort 'opal-repl depends on therubyracer gem, which is not currently installed'
       end
 
+      # Patch V8::Object#respond_to? to avoid MRI warning
+      V8::Object.class_eval do
+        def respond_to?(method, private = false)
+          super or self[method] != nil
+        end
+      end
+
       @v8 = V8::Context.new
       @v8['console'] = self
       @v8.eval Opal::Builder.new.build('opal').to_s
@@ -38,6 +47,7 @@ module Opal
 
     def run_repl
       require 'readline'
+      load_history
 
       loop do
         # on SIGINT lets just return from the loop..
@@ -59,11 +69,23 @@ module Opal
       code = Opal::Builder.new.build_str(str, '(irb)', :irb => true, :const_missing => true)
       code.processed[0...-1].each { |c| @v8.eval(c.to_s) }
       @v8.eval "var $_result = #{code.processed.last.to_s} ($_result == null ? 'nil' : $_result.$inspect());"
-    rescue => e
+    rescue Exception => e
       puts "#{e.message}\n\t#{e.backtrace.join("\n\t")}"
     end
 
+    def load_history
+      return unless @history
+      File.read(@history_path).lines.each { |line| Readline::HISTORY.push line.strip }
+    end
+
+    def dump_history
+      return unless @history
+      length = (Readline::HISTORY.size > 1000) ? 1000 : Readline::HISTORY.size
+      File.write(@history_path, Readline::HISTORY.to_a[-length..-1].join("\n"))
+    end
+
     def finish
+      dump_history
       @v8 = nil
     end
   end

data/lib/opal/ast/builder.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require 'opal/ast/node'
+require 'parser/ruby23'
+
+module Opal
+  module AST
+    class Builder < ::Parser::Builders::Default
+      def n(type, children, location)
+        ::Opal::AST::Node.new(type, children, location: location)
+      end
+    end
+  end
+end

data/lib/opal/ast/node.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require 'ast'
+require 'parser/ast/node'
+
+module Opal
+  module AST
+    class Node < ::Parser::AST::Node
+      attr_reader :meta
+
+      def assign_properties(properties)
+        if meta = properties[:meta]
+          meta = meta.dup if meta.frozen?
+          @meta.merge!(meta)
+        else
+          @meta ||= {}
+        end
+
+        super
+      end
+
+      def line
+        loc.line if loc
+      end
+
+      def column
+        loc.column if loc
+      end
+    end
+  end
+end