opal 0.6.3 → 0.7.0.beta1

data/lib/opal/cli_options.rb

@@ -3,101 +3,147 @@ require 'optparse'
 module Opal
   class CLIOptions < OptionParser
     def initialize
+      super
       @options = {}
 
-      super do |opts|
-        opts.banner = 'Usage: opal [options] -- [programfile]'
-
-        opts.on('-v', '--verbose', 'print version number, then turn on verbose mode') do |v|
-          require 'opal/version'
-          puts "Opal v#{Opal::VERSION}"
-          options[:verbose] = true # TODO: print some warnings when verbose = true
-        end
-
-        opts.on('--version', 'Print the version') do |v|
-          require 'opal/version'
-          puts "Opal v#{Opal::VERSION}"
-          exit
-        end
-
-        opts.on("-h", "--help", "Show this message") do
-          puts opts
-          exit
-        end
-
-        opts.separator ''
-        opts.separator 'Basic Options:'
-
-        opts.on('-I', '--include DIR',
-                'Append a load path (may be used more than once)') do |i|
-          options[:load_paths] ||= []
-          options[:load_paths] << i
-        end
-
-        opts.on('-e', '--eval SOURCE', String,
-                'One line of script. Several -e\'s allowed. Omit [programfile]') do |source|
-          options[:evals] ||= []
-          options[:evals] << source
-        end
-
-        opts.on('-r', '--require LIBRARY', String,
-                'Require the library before executing your script') do |library|
-          options[:requires] ||= []
-          options[:requires] << library
-        end
-
-        opts.on('-s', '--sexp', 'Show Sexps') do
-          options[:sexp] = true
-        end
-
-        opts.on('-m', '--map', 'Show sourcemap') do
-          options[:map] = true
-        end
-
-        opts.on('-c', '--compile', 'Compile to JavaScript') do
-          options[:compile] = true
-        end
-
-        opts.on('-s', '--server [PORT]', 'Start a server (default port: 3000)') do |port|
-          options[:server] = port.to_i
-        end
-
-
-        opts.separator ''
-        opts.separator 'Compilation Options:'
-
-        opts.on('-M', '--[no-]method-missing', 'Disable method missing') do |val|
-          options[:method_missing] = val
-        end
-
-        opts.on('-A', '--[no-]arity-check', 'Enable arity check') do |value|
-          options[:arity_check] = value
-        end
-
-        opts.on('-C', '--[no-]const-missing', 'Disable const missing') do |value|
-          options[:const_missing] = value
-        end
-
-        dynamic_require_levels = %w[error warning ignore]
-        opts.on('-D', '--dynamic-require LEVEL', dynamic_require_levels,
-                      'Set levelDynamic require severity') do |level|
-          options[:dynamic_require_severity] = level.to_sym
-        end
-
-        opts.on('-P', '--no-source-map', 'Disable source map') do |value|
-          options[:source_map_enabled] = false
-        end
-
-        opts.on('-F', '--file FILE', 'Set filename for compiled code') do |file|
-          options[:file] = file
-        end
-
-        opts.on("--[no-]irb", "IRB var mode") do |flag|
-          options[:irb] = flag
-        end
+      self.banner = 'Usage: opal [options] -- [programfile]'
+
+      separator ''
+
+      on('-v', '--verbose', 'print version number, then turn on verbose mode') do
+        print_version
+        options[:verbose] = true # TODO: print some warnings when verbose = true
+      end
+
+      on('--verbose', 'turn on verbose mode') do
+        options[:verbose] = true # TODO: print some warnings when verbose = true
+      end
+
+      on('--version', 'Print the version') do
+        print_version
+        exit
+      end
+
+      on("-h", "--help", "Show this message") do
+        puts self
+        exit
+      end
+
+
+      section 'Basic Options:'
+
+      on('-I', '--include DIR',
+              'Append a load path (may be used more than once)') do |i|
+        options[:load_paths] ||= []
+        options[:load_paths] << i
+      end
+
+      on('-e', '--eval SOURCE', String,
+              'One line of script. Several -e\'s allowed. Omit [programfile]') do |source|
+        options[:evals] ||= []
+        options[:evals] << source
+      end
+
+      on('-r', '--require LIBRARY', String,
+              'Require the library before executing your script') do |library|
+        options[:requires] ||= []
+        options[:requires] << library
+      end
+
+      on('-s', '--stub FILE', String, 'Stubbed files will be compiled as empty files') do |stub|
+        options[:stubs] ||= []
+        options[:stubs] << stub
+      end
+
+      on('-p', '--preload FILE', String, 'Preloaded files will be prepared for dynamic requires') do |stub|
+        options[:preload] ||= []
+        options[:preload] << stub
+      end
+
+      on('-g', '--gem GEM_NAME', String, 'Adds the specified GEM_NAME to Opal\'s load path.') do |g|
+        options[:gems] ||= []
+        options[:gems] << g
+      end
+
+      section 'Running Options:'
+
+      on('--sexp', 'Show Sexps') do
+        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('--runner RUNNER', %w[nodejs server phantomjs], 'Choose the runner: nodejs (default), server') do |runner|
+        options[:runner] = runner.to_sym
+      end
+
+      on('--server-port PORT', 'Set the port for the server runner (default port: 3000)') do |port|
+        options[:runner] = :server
+        options[:port] = port.to_i
+      end
+
+
+      section 'Compilation Options:'
+
+      on('-M', '--no-method-missing', 'Enable/Disable method missing') do
+        options[:method_missing] = false
+      end
+
+      on('-O', '--no-opal', 'Enable/Disable implicit `require "opal"`') do
+        options[:skip_opal_require] = true
+      end
+
+      on('-A', '--arity-check', 'Enable arity check') do
+        options[:arity_check] = true
+      end
+
+      on('-V', 'Enable inline Operators') do
+        options[:inline_operators] = true
+      end
+
+      dynamic_require_levels = %w[error warning ignore]
+      on('-D', '--dynamic-require LEVEL', dynamic_require_levels,
+                    'Set level of dynamic require severity.',
+                    "(deafult: error, values: #{dynamic_require_levels.join(', ')})") do |level|
+        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
+      end
+
+      on('-F', '--file FILE', 'Set filename for compiled code') do |file|
+        options[:file] = file
+      end
+
+      on("--irb", "Enable IRB var mode") do
+        options[:irb] = true
+      end
+
+      separator ''
     end
 
     attr_reader :options
+
+
+    private
+
+    def print_version
+      require 'opal/version'
+      puts "Opal v#{Opal::VERSION}"
+    end
+
+    def section title
+      separator ''
+      separator title
+      separator ''
+    end
   end
 end

data/lib/opal/cli_runners.rb

@@ -0,0 +1,10 @@
+module Opal
+  module CliRunners
+    class RunnerError < StandardError
+    end
+  end
+end
+
+require 'opal/cli_runners/phantomjs'
+require 'opal/cli_runners/nodejs'
+require 'opal/cli_runners/server'

data/lib/opal/cli_runners/nodejs.rb

@@ -0,0 +1,56 @@
+require 'opal/cli_runners'
+
+module Opal
+  module CliRunners
+    class Nodejs
+      def initialize(output)
+        @output ||= output
+      end
+      attr_reader :output
+
+      def puts(*args)
+        output.puts(*args)
+      end
+
+      def node_modules
+        File.expand_path("../../../../node_modules", __FILE__)
+      end
+
+      def run(code, argv)
+        require 'tempfile'
+        tempfile = Tempfile.new('opal-nodejs-runner-')
+        # tempfile = File.new('opal-nodejs-runner.js', 'w') # for debugging
+        tempfile.write code
+        tempfile.close
+        system_with_output({'NODE_PATH' => node_modules}, 'node', tempfile.path , *argv)
+      rescue Errno::ENOENT
+        raise MissingNodeJS, 'Please install Node.js to be able to run Opal scripts.'
+      end
+
+      # Let's support fake IO objects like StringIO
+      def system_with_output(env, *cmd)
+        io_output = IO.try_convert(output)
+        return system(env,*cmd) if io_output
+
+        if RUBY_PLATFORM == 'java'
+          # JRuby has issues in dealing with subprocesses (at least up to 1.7.15)
+          # @headius told me it's mostly fixed on master, but while we wait for it
+          # to ship here's a tempfile workaround.
+          require 'tempfile'
+          require 'shellwords'
+          tempfile = Tempfile.new('opal-node-output')
+          system(env,cmd.shelljoin+" > #{tempfile.path}")
+          captured_output = File.read tempfile.path
+          tempfile.close
+        else
+          require 'open3'
+          captured_output, status = Open3.capture2(env,*cmd)
+        end
+        output.write captured_output
+      end
+
+      class MissingNodeJS < RunnerError
+      end
+    end
+  end
+end

data/lib/opal/cli_runners/phantom.js

@@ -0,0 +1,35 @@
+var page   = require('webpage').create();
+var fs     = require('fs');
+var system = require('system');
+
+page.onConsoleMessage = function(msg) {
+  system.stdout.write(msg);
+};
+
+var opal_code = fs.read('/dev/stdin');
+
+page.onCallback = function(data) {
+  switch (data[0]) {
+  case 'exit':
+    var status = data[1] || 0;
+    phantom.exit(status);
+  case 'stdout':
+    system.stdout.write(data[1] || '');
+    break;
+  case 'stderr':
+    system.stderr.write(data[1] || '');
+    break;
+  default:
+    console.error('Unknown callback data: ', data);
+  }
+};
+
+page.content =  '<!doctype html>'+
+                '<html>'+
+                '  <head><meta charset="utf-8"/></head>'+
+                "  <body><script>//<![CDATA[\n"+
+                opal_code+
+                "  //]]></script>"+
+                '  <script>callPhantom(["exit", 0]);</script></body>\n'+
+                '  </body>'+
+                '</html>';

data/lib/opal/cli_runners/phantomjs.rb

@@ -0,0 +1,28 @@
+require 'shellwords'
+
+module Opal
+  module CliRunners
+    class Phantomjs
+      def initialize(output = $stdout)
+        @output = output
+      end
+      attr_reader :output
+
+      def run(code, argv)
+        unless argv.empty?
+          raise ArgumentError, 'Program arguments are not supported on the PhantomJS runner'
+        end
+
+        phantomjs = IO.popen(command, 'w', out: output) do |io|
+          io.write(code)
+        end
+        exit $?.exitstatus
+      end
+
+      def command
+        script_path = File.expand_path('../phantom.js', __FILE__)
+        "phantomjs #{script_path.shellescape}"
+      end
+    end
+  end
+end

data/lib/opal/cli_runners/server.rb

@@ -0,0 +1,54 @@
+require 'opal/cli_runners'
+
+module Opal
+  module CliRunners
+    class Server
+      def initialize(output, port)
+        @output ||= output || $stdout
+        @port = port
+      end
+      attr_reader :output, :port, :server
+
+      def run(source, argv)
+        unless argv.empty?
+          raise ArgumentError, 'Program arguments are not supported on the PhantomJS runner'
+        end
+
+        require 'rack'
+        require 'webrick'
+        require 'logger'
+
+        @server = Rack::Server.start(
+          :app       => app(source),
+          :Port      => port,
+          :AccessLog => [],
+          :Logger    => Logger.new(output)
+        )
+      end
+
+      def app(source)
+        lambda do |env|
+          case env['PATH_INFO']
+          when '/'
+            body = <<-HTML
+            <!doctype html>
+            <html>
+              <head>
+                <meta charset="utf-8"/>
+                <script>
+                //<![CDATA[
+                #{source}
+                //]]>
+                </script>
+              </head>
+            </html>
+            HTML
+            [200, {}, [body]]
+          else
+            [404, {}, [body]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opal/compiler.rb

@@ -5,7 +5,7 @@ require 'opal/nodes'
 
 module Opal
   def self.compile(source, options = {})
-    Compiler.new.compile(source, options)
+    Compiler.new(source, options).compile
   end
 
   class Compiler
@@ -17,9 +17,13 @@ module Opal
     COMPARE = %w[< > <= >=]
 
     # defines a compiler option, also creating method of form 'name?'
-    def self.compiler_option(name, default_value, mid = nil)
+    def self.compiler_option(name, default_value, options = {})
+      mid          = options[:as]
+      valid_values = options[:valid_values]
       define_method(mid || name) do
-        @options.fetch(name) { default_value }
+        value = @options.fetch(name) { default_value }
+        raise ArgumentError if valid_values and not(valid_values.include?(value))
+        value
       end
     end
 
@@ -27,19 +31,22 @@ module Opal
     compiler_option :file, '(file)'
 
     # adds method stubs for all used methods in file
-    compiler_option :method_missing, true, :method_missing?
+    compiler_option :method_missing, true, :as => :method_missing?
 
     # adds an arity check to every method definition
-    compiler_option :arity_check, false, :arity_check?
-
-    # checks every constant access, delagating to const_missing if needed
-    compiler_option :const_missing, false, :const_missing?
+    compiler_option :arity_check, false, :as => :arity_check?
 
     # compile top level local vars with support for irb style vars
-    compiler_option :irb, false, :irb?
+    compiler_option :irb, false, :as => :irb?
 
     # how to handle dynamic requires (:error, :warning, :ignore)
-    compiler_option :dynamic_require_severity, :error
+    compiler_option :dynamic_require_severity, :error, :valid_values => [:error, :warning, :ignore]
+
+    # Prepare the code for future requires
+    compiler_option :requirable, false, :as => :requirable?
+
+    # are operators compiled inline
+    compiler_option :inline_operators, false, :as => :inline_operators?
 
     attr_reader :result, :fragments
 
@@ -52,16 +59,15 @@ module Opal
     # Any content in __END__ special construct
     attr_reader :eof_content
 
-    def initialize
+    def initialize(source, options = {})
+      @source = source
       @indent = ''
       @unique = 0
-      @options = {}
+      @options = options
     end
 
     # Compile some ruby code to a string.
-    def compile(source, options = {})
-      @source = source
-      @options.update options
+    def compile
       @parser = Parser.new
 
       @sexp = s(:top, @parser.parse(@source, self.file) || s(:nil))
@@ -81,6 +87,11 @@ module Opal
       @helpers ||= Set.new([:breaker, :slice])
     end
 
+    # Operator helpers
+    def operator_helpers
+      @operator_helpers ||= Set.new
+    end
+
     # Method calls made in this file
     def method_calls
       @method_calls ||= Set.new
@@ -97,7 +108,7 @@ module Opal
     # method simply appends the filename and curent line number onto
     # the message and issues a warning.
     def warning(msg, line = nil)
-      warn "#{msg} :#{file}:#{line}"
+      warn "WARNING: #{msg} :#{file}:#{line}"
     end
 
     # Instances of `Scope` can use this to determine the current
@@ -182,6 +193,8 @@ module Opal
     # Process the given sexp by creating a node instance, based on its type,
     # and compiling it to fragments.
     def process(sexp, level = :expr)
+      return fragment('') if sexp == nil
+
       if handler = handlers[sexp.type]
         return handler.new(sexp, level, self).compile_to_fragments
       else
@@ -198,6 +211,12 @@ module Opal
       @requires ||= []
     end
 
+    # An array of trees required in this file
+    # (typically by calling #require_tree)
+    def required_trees
+      @required_trees ||= []
+    end
+
     # The last sexps in method bodies, for example, need to be returned
     # in the compiled javascript. Due to syntax differences between
     # javascript any ruby, some sexps need to be handled specially. For