opal 0.10.0 → 0.11.0

data/lib/opal/builder.rb

@@ -1,15 +1,62 @@
+# frozen_string_literal: true
 require 'opal/path_reader'
-require 'opal/builder_processors'
 require 'opal/paths'
+require 'opal/config'
 require 'set'
 
 module Opal
   class Builder
-    include BuilderProcessors
+    # The registered processors
+    def self.processors
+      @processors ||= []
+    end
+
+    # All the extensions supported by registered processors
+    def self.extensions
+      @extensions ||= []
+    end
+
+    # @public
+    # Register a builder processor and the supported extensions.
+    # A processor will respond to:
+    #
+    # ## `#requires`
+    # An array of string containing the logic paths of required assets
+    #
+    # ## `#required_trees`
+    # An array of string containing the logic paths of required directories
+    #
+    # ## `#to_s`
+    # The processed source
+    #
+    # ## `#source_map`
+    # An instance of `::SourceMap::Map` representing the processd asset's source
+    # map.
+    #
+    # ## `.new(source, filename, compiler_options)`
+    # The processor will be instantiated passing:
+    # - the unprocessed source
+    # - the asset's filename
+    # - Opal's compiler options
+    #
+    # ## `.match?(path)`
+    # The processor is able to recognize paths suitable for its type of
+    # processing.
+    #
+    def self.register_processor(processor, processor_extensions)
+      return if processors.include?(processor)
+      processors << processor
+      processor_extensions.each { |ext| extensions << ext }
+    end
+
+
 
     class MissingRequire < LoadError
     end
 
+    class ProcessorNotFound < LoadError
+    end
+
     def initialize(options = nil)
       (options || {}).each_pair do |k,v|
         public_send("#{k}=", v)
@@ -17,11 +64,10 @@ module Opal
 
       @stubs             ||= []
       @preload           ||= []
-      @processors        ||= DEFAULT_PROCESSORS
-      @path_reader       ||= PathReader.new
+      @processors        ||= ::Opal::Builder.processors
+      @path_reader       ||= PathReader.new(Opal.paths, extensions.map{|e| [".#{e}", ".js.#{e}"]}.flatten)
       @prerequired       ||= []
-      @compiler_options  ||= {}
-      @default_processor ||= RubyProcessor
+      @compiler_options  ||= Opal::Config.compiler_options
 
       @processed = []
     end
@@ -36,7 +82,7 @@ module Opal
     end
 
     def build_str source, filename, options = {}
-      path = path_reader.expand(filename).to_s unless stub?(filename)
+      path = path_from_filename(filename)
       asset = processor_for(source, filename, path, options)
       requires = preload + asset.requires + tree_requires(asset, path)
       requires.map { |r| process_require(r, options) }
@@ -77,9 +123,8 @@ module Opal
 
     attr_reader :processed
 
-    attr_accessor :processors, :default_processor, :path_reader,
-                  :compiler_options, :stubs, :prerequired, :preload
-
+    attr_accessor :processors, :path_reader, :compiler_options,
+                  :stubs, :prerequired, :preload
 
 
 
@@ -108,14 +153,29 @@ module Opal
     end
 
     def processor_for(source, filename, path, options)
-      processor   = processors.find { |p| p.match? path }
-      processor ||= default_processor
-      return processor.new(source, filename, compiler_options.merge(options))
+      processor = processors.find { |p| p.match? path } or
+        raise ProcessorNotFound, "can't find processor for filename: #{filename.inspect}, path: #{path.inspect}, source: #{source.inspect}, processors: #{processors.inspect}"
+      processor.new(source, filename, compiler_options.merge(options))
     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
+        print_list = lambda { |list| "- #{list.join("\n- ")}\n" }
+        message = "can't find file: #{path.inspect} in:\n"+
+                  print_list[path_reader.paths]+
+                  "\nWith the following extensions:\n"+
+                  print_list[path_reader.extensions]+
+                  "\nAnd the following processors:\n"+
+                  print_list[processors]
+
+        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)
@@ -134,12 +194,17 @@ module Opal
         end
       end
 
-      path = path_reader.expand(filename).to_s unless stub?(filename)
+      path = path_from_filename(filename)
       asset = processor_for(source, filename, path, options.merge(requirable: true))
       process_requires(filename, asset.requires+tree_requires(asset, path), options)
       processed << asset
     end
 
+    def path_from_filename(filename)
+      return if stub?(filename)
+      (path_reader.expand(filename) || File.expand_path(filename)).to_s
+    end
+
     def process_requires(filename, requires, options)
       requires.map { |r| process_require(r, options) }
     rescue MissingRequire => error
@@ -155,7 +220,7 @@ module Opal
     end
 
     def extensions
-      @extensions ||= DEFAULT_PROCESSORS.flat_map(&:extensions).compact
+      ::Opal::Builder.extensions
     end
   end
 end

data/lib/opal/builder_processors.rb

@@ -1,16 +1,11 @@
+# frozen_string_literal: true
 require 'opal/compiler'
 require 'opal/erb'
 require 'source_map'
 
 module Opal
   module BuilderProcessors
-    DEFAULT_PROCESSORS = []
-
     class Processor
-      def self.inherited(processor)
-        DEFAULT_PROCESSORS << processor
-      end
-
       def initialize(source, filename, options = {})
         @source, @filename, @options = source, filename, options
         @requires = []
@@ -26,8 +21,10 @@ module Opal
         @extensions = extensions
         matches = extensions.join('|')
         matches = "(#{matches})" if extensions.size == 1
-
         @match_regexp = Regexp.new "\\.#{matches}#{REGEXP_END}"
+
+        ::Opal::Builder.register_processor(self, extensions)
+        nil
       end
 
       def self.extensions
@@ -111,6 +108,11 @@ module Opal
       def compiler_class
         ::Opal::Compiler
       end
+
+      # Also catch a files with missing extensions and nil.
+      def self.match? other
+        super or File.extname(other.to_s) == ''
+      end
     end
 
     class OpalERBProcessor < RubyProcessor

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 = ::Opal::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

data/lib/opal/cli_options.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'optparse'
 
 module Opal
@@ -76,15 +77,11 @@ module Opal
         options[:sexp] = true
       end
 
-      on('-m', '--map', 'Show sourcemap') do
-        options[:map] = true
-      end
-
       on('-c', '--compile', 'Compile to JavaScript') do
         options[:compile] = true
       end
 
-      on('-R', '--runner RUNNER', %w[nodejs server phantomjs applescript nashorn], 'Choose the runner: nodejs (default), server') do |runner|
+      on('-R', '--runner RUNNER', %w[nodejs server applescript nashorn chrome], 'Choose the runner: nodejs (default), server, chrome') do |runner|
         options[:runner] = runner.to_sym
       end
 
@@ -97,10 +94,6 @@ module Opal
         options[:no_exit] = true
       end
 
-      on('-L', '--library', 'Generate only the code of the library. Omit [programfile] and [-e]') do |no_exit|
-        options[:lib_only] = true
-      end
-
       section 'Compilation Options:'
 
       on('-M', '--no-method-missing', 'Enable/Disable method missing') do
@@ -126,19 +119,33 @@ module Opal
         options[:dynamic_require_severity] = level.to_sym
       end
 
-      on('-P', '--source-map [FILE]', 'Enable/Disable source map') do |file|
-        options[:source_map_enabled] = true
-        options[:source_map_file] = file if file
+      on('-P', '--map FILE', 'Enable/Disable source map') do |file|
+        options[:map] = file
       end
 
       on('-F', '--file FILE', 'Set filename for compiled code') do |file|
         options[:file] = file
       end
 
+      on('-L', '--library', 'Compile only required libraries. Omit [programfile] and [-e]. Assumed [-cOE].') do
+        options[:lib_only] = true
+        options[:no_exit] = true
+        options[:compile] = true
+        options[:skip_opal_require] = true
+      end
+
       on("--irb", "Enable IRB var mode") do
         options[:irb] = true
       end
 
+      on('--enable-source-location', 'Compiles source location for each method definition.') do
+        options[:enable_source_location] = true
+      end
+
+      on('--parse-comments', 'Compiles comments for each method definition.') do
+        options[:parse_comments] = true
+      end
+
       separator ''
     end
 

data/lib/opal/cli_runners/applescript.rb

@@ -1,4 +1,4 @@
-require 'opal/cli_runners'
+# frozen_string_literal: true
 
 module Opal
   module CliRunners
@@ -22,15 +22,14 @@ module Opal
         # tempfile = File.new('opal-applescript-runner.js', 'w') # for debugging
         tempfile.write code
         tempfile.close
-        successful = system_with_output('osascript', '-l', 'JavaScript', tempfile.path , *argv)
-
+        _successful = system_with_output('osascript', '-l', 'JavaScript', tempfile.path , *argv)
       rescue Errno::ENOENT
         raise MissingAppleScript, 'AppleScript is only available on Mac OS X.'
       end
 
       # Let's support fake IO objects like StringIO
       def system_with_output(env, *cmd)
-        if (io_output = IO.try_convert(output))
+        if (_io_output = IO.try_convert(output))
           system(env,*cmd)
           @exit_status = $?.exitstatus
           return

data/lib/opal/cli_runners/chrome.js

@@ -0,0 +1,135 @@
+var CDP = require("chrome-remote-interface");
+var fs = require("fs");
+
+// NOTE: the code above doesn't work on Windows
+// and it doesn't support interactive stdin input (which is ok for our scenario)
+var opal_code = fs.readFileSync("/dev/stdin").toString();
+
+// Chrome can't handle huge data passed to `addScriptToEvaluateOnLoad`
+// https://groups.google.com/a/chromium.org/forum/#!topic/chromium-discuss/U5qyeX_ydBo
+// The only way is to create temporary files and pass them to chrome.
+fs.writeFileSync("/tmp/chrome-opal.js", opal_code);
+fs.writeFileSync("/tmp/chrome-opal.html", "" +
+  "<html>" +
+  "<head>" +
+    "<meta charset='utf-8'>" +
+    "<script src='chrome-opal.js'></script>" +
+  "</head>" +
+  "<body>" +
+  "</body>" +
+  "</html>"
+);
+
+var options = {
+  host: process.env.CHROME_HOST || 'localhost',
+  port: process.env.CHROME_PORT || 9222
+};
+
+CDP(options, function(client) {
+  var Page = client.Page,
+      Runtime = client.Runtime,
+      Console = client.Console;
+
+  Promise.all([
+    Console.enable(),
+    Page.enable(),
+    Runtime.enable(),
+  ]).then(function() {
+    // This hook catches only the first argument of `console.log`
+    // More advanced version Runtime.consoleAPICalled returns all arguments
+    // but all of them are not formatted, i.e. by calling
+    //   console.log('string', [1, 2, 3], {a: 'b'})
+    // it returns the following data to the callback:
+    //   {
+    //     "type":"log",
+    //     "args":[
+    //       {
+    //         "type":"string",
+    //         "value":"string"
+    //       },
+    //       {
+    //         "type":"object",
+    //         "subtype":"array",
+    //         "className":"Array",
+    //         "description":"Array(3)",
+    //         "objectId":"{\"injectedScriptId\":11,\"id\":1}",
+    //         "preview":{
+    //           "type":"object",
+    //           "subtype":"array",
+    //           "description":"Array(3)",
+    //           "overflow":false,
+    //           "properties":[
+    //             {"name":"0","type":"number","value":"1"},
+    //             {"name":"1","type":"number","value":"2"},
+    //             {"name":"2","type":"number","value":"3"}
+    //           ]
+    //         }
+    //       },
+    //       {
+    //         "type":"object",
+    //         "className":"Object",
+    //         "description":"Object",
+    //         "objectId":"{\"injectedScriptId\":11,\"id\":2}",
+    //         "preview":{
+    //           "type":"object",
+    //           "description":"Object",
+    //           "overflow":false,
+    //           "properties":[
+    //             {"name":"a","type":"string","value":"b"}
+    //           ]
+    //         }
+    //       }
+    //     ],
+    //     // ...
+    //   }
+    // Supporting this format for complex data structure is challenging, feel free to contribute!
+    //
+    Console.messageAdded(function(console_message) {
+      process.stdout.write(console_message.message.text);
+    });
+
+    Runtime.exceptionThrown(function(exception) {
+      var exceptionDetails = exception.exceptionDetails,
+          properties = exceptionDetails.exception.preview.properties,
+          stackTrace = exceptionDetails.stackTrace.callFrames,
+          name, message, trace = [], i;
+
+
+      for (i = 0; i < properties.length; i++) {
+        var property = properties[i];
+
+        if (property.name == "name") {
+          name = property.value;
+        }
+
+        if (property.name == "message") {
+          message = property.value;
+        }
+      }
+
+      console.log(name + " : " + message);
+
+      for (i = 0; i < stackTrace.length; i++) {
+        var raw = stackTrace[i];
+
+        console.log("    at " + raw.functionName + " (" + raw.url + ":" + raw.lineNumber + ":" + raw.columnNumber + ")")
+      }
+
+      process.exit(1);
+    })
+
+    Page.loadEventFired(() => {
+      Runtime.evaluate({ expression: "window.OPAL_EXIT_CODE" }).then(function(output) {
+        client.close();
+
+        if (typeof(output.result) !== "undefined" && output.result.type === "number") {
+          process.exit(output.result.value);
+        } else {
+          process.exit(0);
+        }
+      })
+    });
+
+    Page.navigate({ url: 'file:///tmp/chrome-opal.html' })
+  });
+});