opal 0.10.6 → 0.11.0.rc1

data/benchmark/bm_module_definition_small.rb

@@ -0,0 +1,30 @@
+module Scope0
+  module Scope1
+    module Scope2
+      module Scope3
+        module Scope4
+          module Scope5
+            module Scope6
+              module Scope7
+                module Scope8
+                  module Scope9
+                    module Scope10
+                      module Scope11
+                        module Scope12
+                          module Scope13
+                            module Scope14
+                            end
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/bin/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/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/rspec.md

@@ -51,7 +51,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/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/lib/opal.rb

@@ -1,12 +1,17 @@
+# frozen_string_literal: true
+require 'opal/config'
 require 'opal/compiler'
 require 'opal/builder'
 require 'opal/erb'
-require 'opal/sprockets'
 require 'opal/paths'
 require 'opal/version'
 require 'opal/errors'
+require 'opal/source_map'
+require 'opal/deprecations'
 
 # Opal is a ruby to javascript compiler, with a runtime for running
 # in any JavaScript environment.
 module Opal
+  autoload :Server, 'opal/server'
+  autoload :SimpleServer, 'opal/simple_server'
 end

data/lib/opal/ast/builder.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require 'opal/ast/node'
+require 'parser/ruby23'
+
+module Opal
+  module AST
+    class Builder < ::Parser::Builders::Default
+      def string_value(token)
+        token[0]
+      end
+
+      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

data/lib/opal/builder.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
 require 'opal/path_reader'
 require 'opal/builder_processors'
 require 'opal/paths'
+require 'opal/config'
 require 'set'
 
 module Opal
@@ -20,7 +22,7 @@ module Opal
       @processors        ||= DEFAULT_PROCESSORS
       @path_reader       ||= PathReader.new
       @prerequired       ||= []
-      @compiler_options  ||= {}
+      @compiler_options  ||= Opal::Config.compiler_options
       @default_processor ||= RubyProcessor
 
       @processed = []
@@ -114,8 +116,17 @@ module Opal
     end
 
     def read(path)
-      path_reader.read(path) or
-        raise MissingRequire, "can't find file: #{path.inspect} in #{path_reader.paths.inspect}"
+      path_reader.read(path) or begin
+        message = "can't find file: #{path.inspect} in #{path_reader.paths.inspect}"
+
+        case compiler_options[:dynamic_require_severity]
+        when :raise   then raise MissingRequire, message
+        when :warning then warn message
+        else # noop
+        end
+
+        return "raise LoadError, #{message.inspect}"
+      end
     end
 
     def process_require(filename, options)

data/lib/opal/builder_processors.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/compiler'
 require 'opal/erb'
 require 'source_map'

data/lib/opal/cli.rb

@@ -1,5 +1,5 @@
+# frozen_string_literal: true
 require 'opal'
-require 'rack'
 require 'opal/builder'
 require 'opal/cli_runners'
 
@@ -9,18 +9,6 @@ module Opal
                 :output, :requires, :gems, :stubs, :verbose, :port, :preload,
                 :filename, :debug, :no_exit, :lib_only
 
-    def compile?
-      @compile
-    end
-
-    def sexp?
-      @sexp
-    end
-
-    def skip_opal_require?
-      @skip_opal_require
-    end
-
     class << self
       attr_accessor :stdout
     end
@@ -29,8 +17,8 @@ module Opal
       options ||= {}
 
       # Runner
-      @runner_type = options.delete(:runner)    || :nodejs
-      @port       = options.delete(:port)       || 3000
+      @runner_type = options.delete(:runner)     || :nodejs
+      @port        = options.delete(:port)       || 3000
 
       @options     = options
       @compile     = !!options.delete(:compile)
@@ -41,7 +29,6 @@ module Opal
       @lib_only    = options.delete(:lib_only)
       @argv        = options.delete(:argv)       || []
       @evals       = options.delete(:evals)      || []
-      @requires    = options.delete(:requires)   || []
       @load_paths  = options.delete(:load_paths) || []
       @gems        = options.delete(:gems)       || []
       @stubs       = options.delete(:stubs)      || []
@@ -50,7 +37,10 @@ module Opal
       @verbose     = options.fetch(:verbose, false); options.delete(:verbose)
       @debug       = options.fetch(:debug, false);   options.delete(:debug)
       @filename    = options.fetch(:filename) { @file && @file.path }; options.delete(:filename)
-      @skip_opal_require = options.delete(:skip_opal_require)
+
+      @requires    = options.delete(:requires)   || []
+      @requires.unshift('opal') unless options.delete(:skip_opal_require)
+
       @compiler_options = Hash[
         *compiler_option_names.map do |option|
           key = option.to_sym
@@ -60,18 +50,23 @@ module Opal
         end.compact.flatten
       ]
 
+      raise ArgumentError, "no libraries to compile" if @lib_only and @requires.length == 0
       raise ArgumentError, "no runnable code provided (evals or file)" if @evals.empty? and @file.nil? and not(@lib_only)
       raise ArgumentError, "can't accept evals or file in `library only` mode" if (@evals.any? or @file) and @lib_only
       raise ArgumentError, "unknown options: #{options.inspect}" unless @options.empty?
     end
 
     def run
-      case
-      when @map;     show_source_map
-      when sexp?;    show_sexp
-      when compile?; show_compiled_source
-      else           run_code
-      end
+      return show_sexp if @sexp
+
+      compiled_source = builder.to_s
+
+      File.write @map, builder.source_map if @map
+
+      return puts compiled_source if @compile
+
+      runner.run(compiled_source, argv)
+      @exit_status = runner.exit_status
     end
 
     def runner
@@ -83,65 +78,51 @@ module Opal
       end
     end
 
-    def run_code
-      runner.run(compiled_source, argv)
-      @exit_status = runner.exit_status
-    end
-
     attr_reader :exit_status
 
-    def build
+    def builder
+      @builder ||= create_builder
+    end
+
+    def create_builder
       builder = Opal::Builder.new stubs: stubs, compiler_options: compiler_options
+
+      # --include
       builder.append_paths(*load_paths)
+
+      # --gem
       gems.each { |gem_name| builder.use_gem gem_name }
 
-      builder.build 'opal' unless skip_opal_require?
+      # --require
+      requires.each { |required| builder.build(required) }
 
+      # --preload
       preload.each { |path| builder.build_require(path) }
 
-      # FLAGS
+      # --verbose
       builder.build_str '$VERBOSE = true', '(flags)' if verbose
-      builder.build_str '$DEBUG = true', '(flags)' if debug
 
-      # REQUIRES: -r
-      requires.each do |local_require|
-        builder.build(local_require)
-      end
+      # --debug
+      builder.build_str '$DEBUG = true', '(flags)' if debug
 
-      unless lib_only
-        evals_or_file do |contents, filename|
-          builder.build_str(contents, filename)
-        end
-      end
+      # --eval / stdin / file
+      evals_or_file { |source, filename| builder.build_str(source, filename) }
 
+      # --no-exit
       builder.build_str 'Kernel.exit', '(exit)' unless no_exit
 
       builder
     end
 
-    def compiled_source
-      build.to_s
-    end
-
-    def show_compiled_source
-      puts compiled_source
-    end
-
     def show_sexp
       evals_or_file do |contents, filename|
-        sexp = Opal::Parser.new.parse(contents, filename)
+        buffer = ::Parser::Source::Buffer.new(filename)
+        buffer.source = contents
+        sexp = Opal::Parser.default_parser.parse(buffer)
         puts sexp.inspect
       end
     end
 
-    def show_source_map
-      evals_or_file do |contents, filename|
-        compiler = Opal::Compiler.new(contents, options.merge(file: filename))
-        compiler.compile
-        puts compiler.source_map.to_json
-      end
-    end
-
     def compiler_option_names
       %w[
         method_missing
@@ -150,12 +131,17 @@ module Opal
         source_map_enabled
         irb_enabled
         inline_operators
+        enable_source_location
+        parse_comments
       ]
     end
 
-    # Internal: Yelds a string of source code and the proper filename for either
+    # Internal: Yields a string of source code and the proper filename for either
     #           evals, stdin or a filepath.
     def evals_or_file
+      # --library
+      return if lib_only
+
       if evals.any?
         yield evals.join("\n"), '-e'
       else