opal-cj 0.7.0.beta1

data/lib/mspec/opal/runner.rb

@@ -0,0 +1,206 @@
+class OSpecFilter
+  def self.main
+    @main ||= self.new
+  end
+
+  def initialize
+    @filters = Set.new
+  end
+
+  def register
+    MSpec.register :exclude, self
+  end
+
+  def ===(description)
+    @filters.include? description
+  end
+
+  def register_filters(description, block)
+    instance_eval(&block)
+  end
+
+  def fails(description)
+    @filters << description
+  end
+end
+
+class Object
+  def opal_filter(description, &block)
+    OSpecFilter.main.register_filters(description, block)
+  end
+end
+
+class BrowserFormatter
+  def initialize(out=nil)
+    @exception = @failure = false
+    @exceptions = []
+    @count = 0
+    @examples = 0
+
+    @current_state = nil
+  end
+
+  def register
+    MSpec.register :exception, self
+    MSpec.register :before,    self
+    MSpec.register :after,     self
+    MSpec.register :start,     self
+    MSpec.register :finish,    self
+    MSpec.register :abort,     self
+    MSpec.register :enter,     self
+  end
+
+  def green(str)
+    `console.info(str)`
+  end
+
+  def red(str)
+    `console.error(str)`
+  end
+
+  def log(str)
+    `console.log(str)`
+  end
+
+  def exception?
+    @exception
+  end
+
+  def failure?
+    @failure
+  end
+
+  def enter(describe); end
+
+  def before(state=nil)
+    @current_state = nil
+    @failure = @exception = false
+  end
+
+  def exception(exception)
+    @count += 1
+    @failure = @exception ? @failure && exception.failure? : exception.failure?
+    @exception = true
+    @exceptions << exception
+  end
+
+  def after(state = nil)
+    @current_state = nil
+    @examples += 1
+  end
+
+  def start
+    @start_time = Time.now.to_f
+  end
+
+  def finish
+    time = Time.now.to_f - @start_time
+
+    if @exceptions.empty?
+      log "\nFinished"
+      green "#{@examples} examples, #{@count} failures (time taken: #{time})"
+
+      finish_with_code 0
+    else
+      log "\nFailures:"
+
+      @exceptions.each_with_index do |exception, idx|
+        log "\n  #{idx + 1}. #{exception.description}"
+        red "\n    #{exception.message}"
+      end
+
+      log "\nFinished"
+      red "#{@examples} examples, #{@count} failures (time taken: #{time})"
+
+      finish_with_code(1)
+    end
+  end
+
+  def finish_with_code(code)
+    `window.OPAL_SPEC_CODE = code;`
+  end
+end
+
+class PhantomFormatter < BrowserFormatter
+  def green(str)
+    `console.log('\033[32m' + str + '\033[0m')`
+  end
+
+  def red(str)
+    `console.log('\033[31m' + str + '\033[0m')`
+  end
+
+  def log(str)
+    `console.log(str)`
+  end
+
+  def after(state)
+    super
+    unless exception?
+      print '.'
+    else
+      print failure? ? 'F' : 'E'
+    end
+  end
+end
+
+class PhantomDebugFormatter < PhantomFormatter
+  def after(state = nil)
+    (@exception && state) ? red(state.description) : green(state.description)
+    super
+  end
+end
+
+module MSpec
+  def self.opal_runner
+    @env = Object.new
+    @env.extend MSpec
+  end
+end
+
+class OSpecRunner
+  def self.main(formatter_class = BrowserFormatter)
+    @main ||= self.new formatter_class
+  end
+
+  def initialize(formatter_class)
+    @formatter_class = formatter_class
+    register
+    run
+  end
+
+  def register
+    formatter = @formatter_class.new
+    formatter.register
+
+    OSpecFilter.main.register
+  end
+
+  def run
+    MSpec.opal_runner
+  end
+
+  def will_start
+    MSpec.actions :start
+  end
+
+  def did_finish
+    MSpec.actions :finish
+  end
+end
+
+module OutputSilencer
+  def silence_stdout
+    original_stdout = $stdout
+    new_stdout = IO.new
+    new_stdout.extend IO::Writable
+    new_stdout.write_proc = ->s{}
+
+    begin
+      $stdout = new_stdout
+      yield
+    ensure
+      $stdout = original_stdout
+    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.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,135 @@
+require 'opal/path_reader'
+require 'opal/builder_processors'
+require 'set'
+
+module Opal
+  class Builder
+    include BuilderProcessors
+
+    def initialize(options = nil)
+      (options || {}).each_pair do |k,v|
+        public_send("#{k}=", v)
+      end
+
+      @compiler_options  ||= {}
+      @default_processor ||= RubyProcessor
+      @processors  ||= DEFAULT_PROCESSORS
+      @stubs       ||= []
+      @preload     ||= []
+      @prerequired ||= []
+      @path_reader ||= PathReader.new
+
+      @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
+    end
+
+    def build_require(path, options = {})
+      process_require(path, options)
+    end
+
+    def to_s
+      processed.map(&:to_s).join("\n")
+    end
+
+    def source_map
+      processed.map(&:source_map).reduce(:+).as_json.to_json
+    end
+
+    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 '|'}))$/, '')
+        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 ArgumentError, "can't find file: #{path.inspect} in #{path_reader.paths.inspect}"
+    end
+
+    def process_require(filename, options)
+      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(asset.requires+tree_requires(asset, path), options)
+      processed << asset
+    end
+
+    def process_requires(requires, options)
+      requires.map { |r| process_require(r, options) }
+    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,165 @@
+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}$"
+      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)
+          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
+      end
+
+      def compiler_class
+        ::Opal::Compiler
+      end
+    end
+
+    class ERBProcessor < 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 HamlProcessor < RubyProcessor
+      handles :haml
+
+      def initialize(*args)
+        super
+        @source = prepare(@source, @filename)
+      end
+
+      def requires
+        ['opal-haml'] + super
+      end
+
+      def prepare(source, path)
+        haml = ::Haml::Engine.new(source, :ugly => true).precompiled
+        haml = haml.gsub('_hamlout.buffer', '_hamlout')
+
+        ::Opal::Haml.wrap haml, path
+      end
+    end
+
+    class ERB_Processor < Processor
+      handles :erb
+
+      def source
+        "Opal.modules[#{@filename.inspect}] = function() {#{::ERB.new(@source.to_s).result}};"
+      end
+    end
+  end
+end