opal-wedge 0.9.0.dev

data/lib/opal/cli_options.rb

@@ -0,0 +1,158 @@
+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
+        exit if ARGV.empty?
+        options[:verbose] = true
+      end
+
+      on('--verbose', 'turn on verbose mode (set $VERBOSE to true)') do
+        options[:verbose] = true
+      end
+
+      on('-d', '--debug', 'turn on debug mode (set $DEBUG to true)') do
+        options[:debug] = 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('-R', '--runner RUNNER', %w[nodejs server phantomjs applescript], '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
+
+      on('--no-exit', 'Do not append a Kernel#exit at the end of file') do |no_exit|
+        options[:no_exit] = true
+      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.',
+                    "(default: 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,11 @@
+module Opal
+  module CliRunners
+    class RunnerError < StandardError
+    end
+  end
+end
+
+require 'opal/cli_runners/apple_script'
+require 'opal/cli_runners/phantomjs'
+require 'opal/cli_runners/nodejs'
+require 'opal/cli_runners/server'

data/lib/opal/cli_runners/apple_script.rb

@@ -0,0 +1,65 @@
+require 'opal/cli_runners'
+
+module Opal
+  module CliRunners
+    class AppleScript
+      def initialize(output)
+        unless system('which osalang > /dev/null')
+          raise MissingJavaScriptSupport, 'JavaScript Automation is only supported by OS X Yosemite and above.'
+        end
+
+        @output ||= output
+      end
+      attr_reader :output, :exit_status
+
+      def puts(*args)
+        output.puts(*args)
+      end
+
+      def run(code, argv)
+        require 'tempfile'
+        tempfile = Tempfile.new('opal-applescript-runner-')
+        # 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)
+
+      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))
+          system(env,*cmd)
+          @exit_status = $?.exitstatus
+          return
+        end
+
+        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-applescript-output')
+          system(env,cmd.shelljoin+" > #{tempfile.path}")
+          @exit_status = $?.exitstatus
+          captured_output = File.read tempfile.path
+          tempfile.close
+        else
+          require 'open3'
+          captured_output, status = Open3.capture2(env,*cmd)
+          @exit_status = status.exitstatus
+        end
+        output.write captured_output
+      end
+
+      class MissingJavaScriptSupport < RunnerError
+      end
+
+      class MissingAppleScript < RunnerError
+      end
+    end
+  end
+end

data/lib/opal/cli_runners/nodejs.rb

@@ -0,0 +1,63 @@
+require 'opal/cli_runners'
+require 'opal/paths'
+
+module Opal
+  module CliRunners
+    class Nodejs
+      def initialize(output)
+        @output ||= output
+      end
+      attr_reader :output, :exit_status
+
+      def puts(*args)
+        output.puts(*args)
+      end
+
+      def node_modules
+        File.expand_path('../stdlib/nodejs/node_modules', ::Opal.gem_dir)
+      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)
+        if IO.try_convert(output)
+          system(env,*cmd)
+          @exit_status = $?.exitstatus
+          return
+        end
+
+        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}")
+          @exit_status = $?.exitstatus
+          captured_output = File.read tempfile.path
+          tempfile.close
+        else
+          require 'open3'
+          captured_output, status = Open3.capture2(env,*cmd)
+          @exit_status = status.exitstatus
+        end
+
+        output.write captured_output
+      end
+
+      class MissingNodeJS < RunnerError
+      end
+    end
+  end
+end

data/lib/opal/cli_runners/phantom.js

@@ -0,0 +1,44 @@
+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');
+
+/*
+ * Exit phantom instance "safely" see - https://github.com/ariya/phantomjs/issues/12697
+ * https://github.com/nobuoka/gulp-qunit/commit/d242aff9b79de7543d956e294b2ee36eda4bac6c
+ */
+function phantom_exit(code) {
+  page.close();
+  setTimeout(function () { phantom.exit(code); }, 0);
+}
+
+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, :exit_status
+
+      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_status = $?.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,56 @@
+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 exit_status
+        nil
+      end
+
+      def app(source)
+        lambda do |env|
+          case env['PATH_INFO']
+          when '/'
+            body = <<-HTML
+            <!doctype html>
+            <html>
+              <head>
+                <meta charset="utf-8"/>
+                <script src="/cli_runner.js"></script>
+              </head>
+            </html>
+            HTML
+            [200, {}, [body]]
+          when '/cli_runner.js'
+            [200, {'Content-Type' => 'text/javascript'}, [source]]
+          else
+            [404, {}, [body]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opal/compiler.rb

@@ -0,0 +1,381 @@
+require 'set'
+require 'opal/parser'
+require 'opal/fragment'
+require 'opal/nodes'
+
+module Opal
+  # Compile a string of ruby code into javascript.
+  #
+  # @example
+  #
+  #     Opal.compile "ruby_code"
+  #     # => "string of javascript code"
+  #
+  # @see Opal::Compiler.new for compiler options
+  #
+  # @param source [String] ruby source
+  # @param options [Hash] compiler options
+  # @return [String] javascript code
+  #
+  def self.compile(source, options = {})
+    Compiler.new(source, options).compile
+  end
+
+  # {Opal::Compiler} is the main class used to compile ruby to javascript code.
+  # This class uses {Opal::Parser} to gather the sexp syntax tree for the ruby
+  # code, and then uses {Opal::Node} to step through the sexp to generate valid
+  # javascript.
+  #
+  # @example
+  #   Opal::Compiler.new("ruby code").compile
+  #   # => "javascript code"
+  #
+  # @example Accessing result
+  #   compiler = Opal::Compiler.new("ruby_code")
+  #   compiler.compile
+  #   compiler.result # => "javascript code"
+  #
+  # @example Source Maps
+  #   compiler = Opal::Compiler.new("")
+  #   compiler.compile
+  #   compiler.source_map # => #<SourceMap:>
+  #
+  class Compiler
+    # Generated code gets indented with two spaces on each scope
+    INDENT = '  '
+
+    # All compare method nodes - used to optimize performance of
+    # math comparisons
+    COMPARE = %w[< > <= >=]
+
+    # defines a compiler option, also creating method of form 'name?'
+    def self.compiler_option(name, default_value, options = {})
+      mid          = options[:as]
+      valid_values = options[:valid_values]
+      define_method(mid || name) do
+        value = @options.fetch(name) { default_value }
+        if valid_values and not(valid_values.include?(value))
+          raise ArgumentError, "invalid value #{value.inspect} for option #{name.inspect} "+
+                                "(valid values: #{valid_values.inspect})"
+        end
+        value
+      end
+    end
+
+    # @!method file
+    #
+    # The filename to use for compiling this code. Used for __FILE__ directives
+    # as well as finding relative require()
+    #
+    # @return [String]
+    compiler_option :file, '(file)'
+
+    # @!method method_missing?
+    #
+    # adds method stubs for all used methods in file
+    #
+    # @return [Boolean]
+    compiler_option :method_missing, true, :as => :method_missing?
+
+    # @!method arity_check?
+    #
+    # adds an arity check to every method definition
+    #
+    # @return [Boolean]
+    compiler_option :arity_check, false, :as => :arity_check?
+
+    # @!method irb?
+    #
+    # compile top level local vars with support for irb style vars
+    compiler_option :irb, false, :as => :irb?
+
+    # @!method dynamic_require_severity
+    #
+    # how to handle dynamic requires (:error, :warning, :ignore)
+    compiler_option :dynamic_require_severity, :error, :valid_values => [:error, :warning, :ignore]
+
+    # @!method requirable?
+    #
+    # Prepare the code for future requires
+    compiler_option :requirable, false, :as => :requirable?
+
+    # @!method inline_operators?
+    #
+    # are operators compiled inline
+    compiler_option :inline_operators, true, :as => :inline_operators?
+
+    # @return [String] The compiled ruby code
+    attr_reader :result
+
+    # @return [Array] all [Opal::Fragment] used to produce result
+    attr_reader :fragments
+
+    # Current scope
+    attr_accessor :scope
+
+    # Current case_stmt
+    attr_reader :case_stmt
+
+    # Any content in __END__ special construct
+    attr_reader :eof_content
+
+    def initialize(source, options = {})
+      @source = source
+      @indent = ''
+      @unique = 0
+      @options = options
+    end
+
+    # Compile some ruby code to a string.
+    #
+    # @return [String] javascript code
+    def compile
+      @parser = Parser.new
+
+      @sexp = s(:top, @parser.parse(@source, self.file) || s(:nil))
+      @eof_content = @parser.lexer.eof_content
+
+      @fragments = process(@sexp).flatten
+
+      @result = @fragments.map(&:code).join('')
+    rescue => error
+      message = "An error occurred while compiling: #{self.file}\n#{error.message}"
+      raise error.class, message, error.backtrace
+    end
+
+    # Returns a source map that can be used in the browser to map back to
+    # original ruby code.
+    #
+    # @param source_file [String] optional source_file to reference ruby source
+    # @return [Opal::SourceMap]
+    def source_map(source_file = nil)
+      Opal::SourceMap.new(@fragments, source_file || self.file)
+    end
+
+    # Any helpers required by this file. Used by {Opal::Nodes::Top} to reference
+    # runtime helpers that are needed. These are used to minify resulting
+    # javascript by keeping a reference to helpers used.
+    #
+    # @return [Set<Symbol>]
+    def helpers
+      @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
+    end
+
+    # This is called when a parsing/processing error occurs. This
+    # method simply appends the filename and curent line number onto
+    # the message and raises it.
+    def error(msg, line = nil)
+      raise SyntaxError, "#{msg} :#{file}:#{line}"
+    end
+
+    # This is called when a parsing/processing warning occurs. This
+    # method simply appends the filename and curent line number onto
+    # the message and issues a warning.
+    def warning(msg, line = nil)
+      warn "WARNING: #{msg} -- #{file}:#{line}"
+    end
+
+    # Instances of `Scope` can use this to determine the current
+    # scope indent. The indent is used to keep generated code easily
+    # readable.
+    def parser_indent
+      @indent
+    end
+
+    # Create a new sexp using the given parts. Even though this just
+    # returns an array, it must be used incase the internal structure
+    # of sexps does change.
+    def s(*parts)
+      Sexp.new(parts)
+    end
+
+    def fragment(str, sexp = nil)
+      Fragment.new(str, sexp)
+    end
+
+    # Used to generate a unique id name per file. These are used
+    # mainly to name method bodies for methods that use blocks.
+    def unique_temp
+      "TMP_#{@unique += 1}"
+    end
+
+    # Use the given helper
+    def helper(name)
+      self.helpers << name
+    end
+
+    # To keep code blocks nicely indented, this will yield a block after
+    # adding an extra layer of indent, and then returning the resulting
+    # code after reverting the indent.
+    def indent(&block)
+      indent = @indent
+      @indent += INDENT
+      @space = "\n#@indent"
+      res = yield
+      @indent = indent
+      @space = "\n#@indent"
+      res
+    end
+
+    # Temporary varibales will be needed from time to time in the
+    # generated code, and this method will assign (or reuse) on
+    # while the block is yielding, and queue it back up once it is
+    # finished. Variables are queued once finished with to save the
+    # numbers of variables needed at runtime.
+    def with_temp(&block)
+      tmp = @scope.new_temp
+      res = yield tmp
+      @scope.queue_temp tmp
+      res
+    end
+
+    # Used when we enter a while statement. This pushes onto the current
+    # scope's while stack so we know how to handle break, next etc.
+    def in_while
+      return unless block_given?
+      @while_loop = @scope.push_while
+      result = yield
+      @scope.pop_while
+
+      result
+    end
+
+    def in_case
+      return unless block_given?
+      old = @case_stmt
+      @case_stmt = {}
+      yield
+      @case_stmt = old
+    end
+
+    # Returns true if the parser is curently handling a while sexp,
+    # false otherwise.
+    def in_while?
+      @scope.in_while?
+    end
+
+    # 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
+        raise "Unsupported sexp: #{sexp.type}"
+      end
+    end
+
+    def handlers
+      @handlers ||= Opal::Nodes::Base.handlers
+    end
+
+    # An array of requires used in this file
+    def requires
+      @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
+    # example, `if` statemented cannot be returned in javascript, so
+    # instead the "truthy" and "falsy" parts of the if statement both
+    # need to be returned instead.
+    #
+    # Sexps that need to be returned are passed to this method, and the
+    # alterned/new sexps are returned and should be used instead. Most
+    # sexps can just be added into a `s(:return) sexp`, so that is the
+    # default action if no special case is required.
+    def returns(sexp)
+      return returns s(:nil) unless sexp
+
+      case sexp.type
+      when :break, :next, :redo
+        sexp
+      when :yield
+        sexp[0] = :returnable_yield
+        sexp
+      when :scope
+        sexp[1] = returns sexp[1]
+        sexp
+      when :block
+        if sexp.length > 1
+          sexp[-1] = returns sexp[-1]
+        else
+          sexp << returns(s(:nil))
+        end
+        sexp
+      when :when
+        sexp[2] = returns(sexp[2])
+        sexp
+      when :rescue
+        sexp[1] = returns sexp[1]
+
+        if sexp[2] and sexp[2][0] == :resbody
+          if sexp[2][2]
+            sexp[2][2] = returns sexp[2][2]
+          else
+            sexp[2][2] = returns s(:nil)
+          end
+        end
+        sexp
+      when :ensure
+        sexp[1] = returns sexp[1]
+        sexp
+      when :begin
+        sexp[1] = returns sexp[1]
+        sexp
+      when :rescue_mod
+        sexp[1] = returns sexp[1]
+        sexp[2] = returns sexp[2]
+        sexp
+      when :while
+        # sexp[2] = returns(sexp[2])
+        sexp
+      when :return, :js_return
+        sexp
+      when :xstr
+        sexp[1] = "return #{sexp[1]};" unless /return|;/ =~ sexp[1]
+        sexp
+      when :dxstr
+        sexp[1] = "return #{sexp[1]}" unless /return|;|\n/ =~ sexp[1]
+        sexp
+      when :if
+        sexp[2] = returns(sexp[2] || s(:nil))
+        sexp[3] = returns(sexp[3] || s(:nil))
+        sexp
+      else
+        s(:js_return, sexp).tap { |s|
+          s.source = sexp.source
+        }
+      end
+    end
+
+    def handle_block_given_call(sexp)
+      @scope.uses_block!
+      if @scope.block_name
+        fragment("(#{@scope.block_name} !== nil)", sexp)
+      elsif scope = @scope.find_parent_def and scope.block_name
+        fragment("(#{scope.block_name} !== nil)", sexp)
+      else
+        fragment("false", sexp)
+      end
+    end
+  end
+end