opal-cj 0.7.0.beta1

data/lib/opal/cli.rb

@@ -0,0 +1,145 @@
+require 'opal'
+require 'rack'
+require 'opal/builder'
+require 'opal/cli_runners'
+
+module Opal
+  class CLI
+    attr_reader :options, :file, :compiler_options, :evals, :load_paths, :argv,
+                :output, :requires, :gems, :stubs, :verbose, :port, :preload
+
+    def compile?
+      @compile
+    end
+
+    def sexp?
+      @sexp
+    end
+
+    def skip_opal_require?
+      @skip_opal_require
+    end
+
+    class << self
+      attr_accessor :stdout
+    end
+
+    def initialize options = nil
+      options ||= {}
+
+      # Runner
+      @runner_type = options.delete(:runner)    || :nodejs
+      @port       = options.delete(:port)       || 3000
+
+      @options    = options
+      @compile    = !!options.delete(:compile)
+      @sexp       = options.delete(:sexp)
+      @file       = options.delete(:file)
+      @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)      || []
+      @preload    = options.delete(:preload)    || []
+      @output     = options.delete(:output)     || self.class.stdout || $stdout
+      @verbose    = options.fetch(:verbose, false); options.delete(:verbose)
+      @skip_opal_require = options.delete(:skip_opal_require)
+      @compiler_options = Hash[
+        *processor_option_names.map do |option|
+          key = option.to_sym
+          next unless options.has_key? key
+          value = options.delete(key)
+          [key, value]
+        end.compact.flatten
+      ]
+
+      raise ArgumentError, "no runnable code provided (evals or file)" if @evals.empty? and @file.nil?
+      raise ArgumentError, "unknown options: #{options.inspect}" unless @options.empty?
+    end
+
+    def run
+      case
+      when sexp?;    show_sexp
+      when compile?; show_compiled_source
+      else           run_code
+      end
+    end
+
+    def runner
+      @runner ||= case @runner_type
+                  when :server;    CliRunners::Server.new(output, port)
+                  when :nodejs;    CliRunners::Nodejs.new(output)
+                  when :phantomjs; CliRunners::Phantomjs.new(output)
+                  else raise ArgumentError, @runner_type.inspect
+                  end
+    end
+
+    def run_code
+      runner.run(compiled_source, argv)
+    end
+
+    def compiled_source
+      Opal.paths.concat load_paths
+      gems.each { |gem_name| Opal.use_gem gem_name }
+
+      builder = Opal::Builder.new stubs: stubs, compiler_options: compiler_options
+
+      builder.build 'opal' unless skip_opal_require?
+
+      preload.each { |path| builder.build_require(path) }
+
+      # REQUIRES: -r
+      requires.each do |local_require|
+        builder.build_str("require #{local_require.inspect}", 'require')
+      end
+
+      if evals.any?
+        builder.build_str(evals.join("\n"), '-e')
+      else
+        if file and (file.path != '-' or evals.empty?)
+          builder.build_str(file.read, file.path)
+        end
+      end
+
+      builder.to_s
+    end
+
+    def show_compiled_source
+      puts compiled_source
+    end
+
+    def show_sexp
+      if evals.any?
+        sexp = Opal::Parser.new.parse(evals.join("\n"), '-e')
+      else
+        if file and (file.path != '-' or evals.empty?)
+          sexp = Opal::Parser.new.parse(file.read, file.path)
+        end
+      end
+      puts sexp.inspect
+    end
+
+    def map
+      compiler = Opal::Compiler.compile(file.read, options.merge(:file => file.path))
+      compiler.compile
+      compiler.source_map
+    end
+
+    def processor_option_names
+      %w[
+        method_missing_enabled
+        arity_check_enabled
+        dynamic_require_severity
+        source_map_enabled
+        irb_enabled
+        inline_operators
+      ]
+    end
+
+    def puts(*args)
+      output.puts(*args)
+    end
+
+  end
+end

data/lib/opal/cli_options.rb

@@ -0,0 +1,149 @@
+require 'optparse'
+
+module Opal
+  class CLIOptions < OptionParser
+    def initialize
+      super
+      @options = {}
+
+      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