opal-wedge 0.9.0.dev

data/lib/mspec/opal/special_calls.rb

@@ -0,0 +1,44 @@
+require 'opal/nodes'
+
+class Opal::Nodes::CallNode
+  # Rubyspec uses this call to load in language specific features at runtime.
+  # We can't do this at runtime, so handle it during compilation
+  add_special :language_version do
+    if scope.top?
+      lang_type = arglist[2][1]
+      target = "rubyspec/language/versions/#{lang_type}_1.9"
+
+      if File.exist?(target)
+        compiler.requires << target
+      end
+
+      push fragment("nil")
+    end
+  end
+
+  add_special :not_supported_on do
+    unless arglist.flatten.include? :opal
+      compile_default!
+    end
+  end
+
+  add_special :not_compliant_on do
+    unless arglist.flatten.include? :opal
+      compile_default!
+    end
+  end
+
+  add_special :platform_is_not do
+    unless arglist.flatten.include? :opal
+      compile_default!
+    end
+  end
+
+  add_special :platform_is do
+    if arglist.flatten.include? :opal
+      compile_default!
+    end
+  end
+end
+
+

data/lib/mspec/opal/sprockets.js

@@ -0,0 +1,57 @@
+/*
+ * Test runner for phantomjs
+ */
+var args = phantom.args;
+var page = require('webpage').create();
+
+page.onConsoleMessage = function(msg) {
+  console.log(msg);
+};
+
+page.onInitialized = function() {
+  page.evaluate(function () {
+    window.OPAL_SPEC_PHANTOM = true;
+  });
+};
+
+var system = require('system');
+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.open(args[0], function(status) {
+  if (status !== 'success') {
+    console.error("Cannot load: " + args[0]);
+    phantom.exit(1);
+  } else {
+    var timeout = parseInt(args[1] || 60000, 10);
+    var start = Date.now();
+    var interval = setInterval(function() {
+      if (Date.now() > start + timeout) {
+        console.error("Specs timed out");
+        phantom.exit(124);
+      } else {
+        var code = page.evaluate(function() {
+          return window.OPAL_SPEC_CODE;
+        });
+
+        if (code === 0 || code === 1) {
+          clearInterval(interval);
+          phantom.exit(code);
+        }
+      }
+    }, 500);
+  }
+});

data/lib/opal-wedge.rb

@@ -0,0 +1,4 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'opal'

data/lib/opal.rb

@@ -0,0 +1,11 @@
+require 'opal/compiler'
+require 'opal/builder'
+require 'opal/erb'
+require 'opal/sprockets'
+require 'opal/paths'
+require 'opal/version'
+
+# Opal is a ruby to javascript compiler, with a runtime for running
+# in any javascript environment.
+module Opal
+end

data/lib/opal/builder.rb

@@ -0,0 +1,161 @@
+require 'opal/path_reader'
+require 'opal/builder_processors'
+require 'opal/paths'
+require 'set'
+
+module Opal
+  class Builder
+    include BuilderProcessors
+
+    class MissingRequire < LoadError
+    end
+
+    def initialize(options = nil)
+      (options || {}).each_pair do |k,v|
+        public_send("#{k}=", v)
+      end
+
+      @stubs             ||= []
+      @preload           ||= []
+      @processors        ||= DEFAULT_PROCESSORS
+      @path_reader       ||= PathReader.new
+      @prerequired       ||= []
+      @compiler_options  ||= {}
+      @default_processor ||= RubyProcessor
+
+      @processed = []
+    end
+
+    def self.build(*args, &block)
+      new.build(*args, &block)
+    end
+
+    def build(path, options = {})
+      source = read(path)
+      build_str(source, path, options)
+    end
+
+    def build_str source, filename, options = {}
+      path = path_reader.expand(filename).to_s unless stub?(filename)
+      asset = processor_for(source, filename, path, options)
+      requires = preload + asset.requires + tree_requires(asset, path)
+      requires.map { |r| process_require(r, options) }
+      processed << asset
+      self
+    rescue MissingRequire => error
+      raise error, "A file required by #{filename.inspect} wasn't found.\n#{error.message}", error.backtrace
+    end
+
+    def build_require(path, options = {})
+      process_require(path, options)
+    end
+
+    def initialize_copy(other)
+      super
+      @stubs = other.stubs.dup
+      @preload = other.preload.dup
+      @processors = other.processors.dup
+      @path_reader = other.path_reader.dup
+      @prerequired = other.prerequired.dup
+      @compiler_options = other.compiler_options.dup
+      @processed = other.processed.dup
+    end
+
+    def to_s
+      processed.map(&:to_s).join("\n")
+    end
+
+    def source_map
+      processed.map(&:source_map).reduce(:+).as_json.to_json
+    end
+
+    def append_paths(*paths)
+      path_reader.append_paths(*paths)
+    end
+
+    include UseGem
+
+    attr_reader :processed
+
+    attr_accessor :processors, :default_processor, :path_reader,
+                  :compiler_options, :stubs, :prerequired, :preload
+
+
+
+
+    private
+
+    def tree_requires(asset, path)
+      if path.nil? or path.empty?
+        dirname = Dir.pwd
+      else
+        dirname = File.dirname(File.expand_path(path))
+      end
+
+      paths = path_reader.paths.map{|p| File.expand_path(p)}
+
+      asset.required_trees.flat_map do |tree|
+        expanded = File.expand_path(tree, dirname)
+        base = paths.find { |p| expanded.start_with?(p) }
+        next [] if base.nil?
+
+        globs = extensions.map { |ext| File.join base, tree, '**', "*.#{ext}" }
+
+        Dir[*globs].map do |file|
+          Pathname(file).relative_path_from(Pathname(base)).to_s.gsub(/(\.js)?(\.(?:#{extensions.join '|'}))#{REGEXP_END}/, '')
+        end
+      end
+    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))
+    end
+
+    def read(path)
+      path_reader.read(path) or
+        raise MissingRequire, "can't find file: #{path.inspect} in #{path_reader.paths.inspect}"
+    end
+
+    def process_require(filename, options)
+      filename.gsub!(/\.(rb|js|opal)#{REGEXP_END}/, '')
+      return if prerequired.include?(filename)
+      return if already_processed.include?(filename)
+      already_processed << filename
+
+      source = stub?(filename) ? '' : read(filename)
+
+      if source.nil?
+        message = "can't find file: #{filename.inspect}"
+        case @compiler_options[:dynamic_require_severity]
+        when :error then raise LoadError, message
+        when :warning then warn "can't find file: #{filename.inspect}"
+        end
+      end
+
+      path = path_reader.expand(filename).to_s unless stub?(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 process_requires(filename, requires, options)
+      requires.map { |r| process_require(r, options) }
+    rescue MissingRequire => error
+      raise error, "A file required by #{filename.inspect} wasn't found.\n#{error.message}", error.backtrace
+    end
+
+    def already_processed
+      @already_processed ||= Set.new
+    end
+
+    def stub? filename
+      stubs.include?(filename)
+    end
+
+    def extensions
+      @extensions ||= DEFAULT_PROCESSORS.flat_map(&:extensions).compact
+    end
+  end
+end

data/lib/opal/builder_processors.rb

@@ -0,0 +1,149 @@
+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 = []
+        @required_trees = []
+      end
+      attr_reader :source, :filename, :options, :requires, :required_trees
+
+      def to_s
+        source.to_s
+      end
+
+      def self.handles(*extensions)
+        @extensions = extensions
+        matches = extensions.join('|')
+        matches = "(#{matches})" if extensions.size == 1
+
+        @match_regexp = Regexp.new "\\.#{matches}#{REGEXP_END}"
+      end
+
+      def self.extensions
+        @extensions
+      end
+
+      def self.match? other
+        (other.is_a?(String) and other.match(match_regexp))
+      end
+
+      def self.match_regexp
+        @match_regexp or raise NotImplementedError
+      end
+
+      def source_map
+        @source_map ||= begin
+          mappings = []
+          source_file = filename+'.js'
+          line = source.count("\n")
+          column = source.scan("\n[^\n]*$").size
+          offset = ::SourceMap::Offset.new(line, column)
+          mappings << ::SourceMap::Mapping.new(source_file, offset, offset)
+
+          # Ensure mappings isn't empty: https://github.com/maccman/sourcemap/issues/11
+          unless mappings.any?
+            zero_offset = ::SourceMap::Offset.new(0,0)
+            mappings = [::SourceMap::Mapping.new(source_file,zero_offset,zero_offset)]
+          end
+
+          ::SourceMap::Map.new(mappings)
+        end
+      end
+
+      def mark_as_required(filename)
+        "Opal.mark_as_loaded(Opal.normalize_loadable_path(#{filename.to_s.inspect}));"
+      end
+    end
+
+    class JsProcessor < Processor
+      handles :js
+
+      def source
+        @source.to_s + mark_as_required(@filename)
+      end
+    end
+
+    class RubyProcessor < Processor
+      handles :rb, :opal
+
+      def source
+        compiled.result
+      end
+
+      def source_map
+        compiled.source_map.map
+      end
+
+      def compiled
+        @compiled ||= begin
+          compiler = compiler_for(@source, file: @filename.gsub(/\.(rb|js|opal)#{REGEXP_END}/, ''))
+          compiler.compile
+          compiler
+        end
+      end
+
+      def compiler_for(source, options = {})
+        compiler_class.new(source, @options.merge(options))
+      end
+
+      def requires
+        compiled.requires
+      end
+
+      def required_trees
+        compiled.required_trees.map do |tree|
+          # Remove any leading ./ after joining to dirname
+          File.join(File.dirname(@filename), tree).sub(%r{^(\./)*}, '')
+        end
+      end
+
+      def compiler_class
+        ::Opal::Compiler
+      end
+    end
+
+    class OpalERBProcessor < RubyProcessor
+      handles :opalerb
+
+      def initialize(*args)
+        super
+        @source = prepare(@source, @filename)
+      end
+
+      def requires
+        ['erb']+super
+      end
+
+      private
+
+      def erb_compiler_class
+        ::Opal::ERB::Compiler
+      end
+
+      def prepare(source, path)
+        erb_compiler = erb_compiler_class.new(source, path)
+        erb_compiler.prepared_source
+      end
+    end
+
+    class ERBProcessor < Processor
+      handles :erb
+
+      def source
+        result = ::ERB.new(@source.to_s).result
+        "Opal.modules[#{@filename.inspect}] = function() {#{result}};"
+      end
+    end
+  end
+end

data/lib/opal/cli.rb

@@ -0,0 +1,162 @@
+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,
+                :filename, :debug, :no_exit
+
+    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)
+      @no_exit    = options.delete(:no_exit)
+      @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)
+      @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)
+      @compiler_options = Hash[
+        *compiler_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)
+                  when :applescript; CliRunners::AppleScript.new(output)
+                  else raise ArgumentError, @runner_type.inspect
+                  end
+    end
+
+    def run_code
+      runner.run(compiled_source, argv)
+      @exit_status = runner.exit_status
+    end
+
+    attr_reader :exit_status
+
+    def build
+      builder = Opal::Builder.new stubs: stubs, compiler_options: compiler_options
+      builder.append_paths(*load_paths)
+      gems.each { |gem_name| builder.use_gem gem_name }
+
+      builder.build 'opal' unless skip_opal_require?
+
+      preload.each { |path| builder.build_require(path) }
+
+      # FLAGS
+      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
+
+      if evals.any?
+        builder.build_str(evals.join("\n"), '-e')
+      else
+        if file and (filename != '-' or evals.empty?)
+          builder.build_str(file.read, filename)
+        end
+      end
+
+      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
+      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 compiler_option_names
+      %w[
+        method_missing
+        arity_check
+        dynamic_require_severity
+        source_map_enabled
+        irb_enabled
+        inline_operators
+      ]
+    end
+
+    def puts(*args)
+      output.puts(*args)
+    end
+
+  end
+end