opal-cj 0.7.0.beta1

data/stdlib/opal-parser.rb

@@ -0,0 +1,53 @@
+require 'opal/compiler'
+require 'opal/erb'
+require 'opal/version'
+
+module Kernel
+  def eval(str)
+    code = Opal.compile str, file: '(eval)'
+    `eval(#{code})`
+  end
+
+  def require_remote url
+    %x{
+      var r = new XMLHttpRequest();
+      r.open("GET", url, false);
+      r.send('');
+    }
+    eval `r.responseText`
+  end
+end
+
+%x{
+  Opal.compile = function(str, options) {
+    if (options) {
+      options = Opal.hash(options);
+    }
+    return Opal.Opal.$compile(str, options);
+  };
+
+  Opal.eval = function(str, options) {
+   return eval(Opal.compile(str, options));
+  };
+
+  function run_ruby_scripts() {
+    var tag, tags = document.getElementsByTagName('script');
+
+    for (var i = 0, len = tags.length; i < len; i++) {
+      tag = tags[i];
+      if (tag.type === "text/ruby") {
+        if (tag.src)       Opal.Kernel.$require_remote(tag.src);
+        if (tag.innerHTML) Opal.Kernel.$eval(tag.innerHTML);
+      }
+    }
+  }
+
+  if (typeof(document) !== 'undefined') {
+    if (window.addEventListener) {
+      window.addEventListener('DOMContentLoaded', run_ruby_scripts, false);
+    }
+    else {
+      window.attachEvent('onload', run_ruby_scripts);
+    }
+  }
+}

data/stdlib/opal-source-maps.rb

@@ -0,0 +1,2 @@
+require 'source_map'
+require 'opal/source_map'

data/stdlib/ostruct.rb

@@ -0,0 +1,69 @@
+class OpenStruct
+  def initialize(hash = nil)
+    @table = {}
+
+    hash.each_pair {|key, value|
+      @table[key.to_sym] = value
+    } if hash
+  end
+
+  def [](name)
+    @table[name.to_sym]
+  end
+
+  def []=(name, value)
+    @table[name.to_sym] = value
+  end
+
+  def method_missing(name, *args)
+    if name.end_with? '='
+      @table[name[0 .. -2].to_sym] = args[0]
+    else
+      @table[name.to_sym]
+    end
+  end
+
+  def each_pair
+    return enum_for :each_pair unless block_given?
+
+    @table.each_pair {|pair|
+      yield pair
+    }
+  end
+
+  def ==(other)
+    return false unless other.is_a?(OpenStruct)
+
+    @table == other.instance_variable_get(:@table)
+  end
+
+  def ===(other)
+    return false unless other.is_a?(OpenStruct)
+
+    @table === other.instance_variable_get(:@table)
+  end
+
+  def eql?(other)
+    return false unless other.is_a?(OpenStruct)
+
+    @table.eql? other.instance_variable_get(:@table)
+  end
+
+  def to_h
+    @table.dup
+  end
+
+  def to_n
+    @table.to_n
+  end
+
+  def hash
+    @table.hash
+  end
+
+  def inspect
+    "#<#{self.class}: #{each_pair.map {|name, value|
+      "#{name}=#{self[name].inspect}"
+    }.join(" ")}>"
+  end
+end

data/stdlib/pathname.rb

@@ -0,0 +1,31 @@
+class Pathname
+  def initialize path
+    raise ArgumentError if path == "\0"
+    @path = path
+  end
+
+  attr_reader :path
+
+  def == other
+    other.path == @path
+  end
+
+  def absolute?
+    @path.start_with? '/'
+  end
+
+  def relative?
+    !absolute?
+  end
+
+  def to_path
+    @path
+  end
+  alias :to_str :to_path
+  alias :to_s :to_path
+end
+
+module Kernel
+  def Pathname(path)
+  end
+end

data/stdlib/phantomjs.rb

@@ -0,0 +1,8 @@
+module Kernel
+  def exit status = 0
+    `callPhantom(['exit', status]);`
+  end
+end
+
+STDOUT.write_proc = `function(str){callPhantom(['stdout', str])}`
+STDERR.write_proc = `function(str){callPhantom(['stderr', str])}`

data/stdlib/pp.rb

@@ -0,0 +1,12 @@
+module Kernel
+  def pretty_inspect; inspect; end
+
+  if `(typeof console === "undefined" || typeof console.log === "undefined")`
+    alias :pp :p
+  else
+    def pp *args
+      args.each { |obj| `console.log(obj);` }
+      args.length <= 1 ? args[0] : args
+    end
+  end
+end

data/stdlib/process.rb

@@ -0,0 +1,10 @@
+class Process
+  def self.pid
+    0
+  end
+end
+
+class Signal
+  def self.trap(*)
+  end
+end

data/stdlib/promise.rb

@@ -0,0 +1,300 @@
+class Promise
+  def self.value(value)
+    new.resolve(value)
+  end
+
+  def self.error(value)
+    new.reject(value)
+  end
+
+  def self.when(*promises)
+    When.new(promises)
+  end
+
+  attr_reader :value, :error, :prev, :next
+
+  def initialize(success = nil, failure = nil)
+    @success = success
+    @failure = failure
+
+    @realized  = nil
+    @exception = false
+    @value     = nil
+    @error     = nil
+    @delayed   = nil
+
+    @prev = nil
+    @next = nil
+  end
+
+  def act?
+    @success != nil
+  end
+
+  def exception?
+    @exception
+  end
+
+  def realized?
+    @realized != nil
+  end
+
+  def resolved?
+    @realized == :resolve
+  end
+
+  def rejected?
+    @realized == :reject
+  end
+
+  def ^(promise)
+    promise << self
+    self    >> promise
+
+    promise
+  end
+
+  def <<(promise)
+    @prev = promise
+
+    self
+  end
+
+  def >>(promise)
+    @next = promise
+
+    if exception?
+      promise.reject(@delayed)
+    elsif resolved?
+      promise.resolve(@delayed || value)
+    elsif rejected? && (!@failure || Promise === (@delayed || @error))
+      promise.reject(@delayed || error)
+    end
+
+    self
+  end
+
+  def resolve(value = nil)
+    if realized?
+      raise ArgumentError, 'the promise has already been realized'
+    end
+
+    if Promise === value
+      value << @prev
+
+      return value ^ self
+    end
+
+    @realized = :resolve
+    @value    = value
+
+    begin
+      if @success
+        value = @success.call(value)
+      end
+
+      resolve!(value)
+    rescue Exception => e
+      exception!(e)
+    end
+
+    self
+  end
+
+  def resolve!(value)
+    if @next
+      @next.resolve(value)
+    else
+      @delayed = value
+    end
+  end
+
+  def reject(value = nil)
+    if realized?
+      raise ArgumentError, 'the promise has already been realized'
+    end
+
+    if Promise === value
+      value << @prev
+
+      return value ^ self
+    end
+
+    @realized = :reject
+    @error    = value
+
+    begin
+      if @failure
+        value = @failure.call(value)
+
+        if Promise === value
+          reject!(value)
+        end
+      else
+        reject!(value)
+      end
+    rescue Exception => e
+      exception!(e)
+    end
+
+    self
+  end
+
+  def reject!(value)
+    if @next
+      @next.reject(value)
+    else
+      @delayed = value
+    end
+  end
+
+  def exception!(error)
+    @exception = true
+
+    reject!(error)
+  end
+
+  def then(&block)
+    self ^ Promise.new(block)
+  end
+
+  alias do then
+
+  def fail(&block)
+    self ^ Promise.new(nil, block)
+  end
+
+  alias rescue fail
+  alias catch fail
+
+  def always(&block)
+    self ^ Promise.new(block, block)
+  end
+
+  alias finally always
+  alias ensure always
+
+  def trace(depth = nil, &block)
+    self ^ Trace.new(depth, block)
+  end
+
+  def inspect
+    result = "#<#{self.class}(#{object_id})"
+
+    if @next
+      result += " >> #{@next.inspect}"
+    end
+
+    if realized?
+      result += ": #{(@value || @error).inspect}>"
+    else
+      result += ">"
+    end
+
+    result
+  end
+
+  class Trace < self
+    def self.it(promise)
+      unless promise.realized?
+        raise ArgumentError, "the promise hasn't been realized"
+      end
+
+      current = promise.act? ? [promise.value] : []
+
+      if prev = promise.prev
+        current.concat(it(prev))
+      else
+        current
+      end
+    end
+
+    def initialize(depth, block)
+      @depth = depth
+
+      super -> {
+        trace = Trace.it(self).reverse
+
+        if depth && depth <= trace.length
+          trace.shift(trace.length - depth)
+        end
+
+        block.call(*trace)
+      }
+    end
+  end
+
+  class When < self
+    def initialize(promises = [])
+      super()
+
+      @wait = []
+
+      promises.each {|promise|
+        wait promise
+      }
+    end
+
+    def each(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      self.then {|values|
+        values.each(&block)
+      }
+    end
+
+    def collect(&block)
+      raise ArgumentError, 'no block given' unless block
+
+      self.then {|values|
+        When.new(values.map(&block))
+      }
+    end
+
+    def inject(*args, &block)
+      self.then {|values|
+        values.reduce(*args, &block)
+      }
+    end
+
+    alias map collect
+
+    alias reduce inject
+
+    def wait(promise)
+      unless Promise === promise
+        promise = Promise.value(promise)
+      end
+
+      if promise.act?
+        promise = promise.then
+      end
+
+      @wait << promise
+
+      promise.always {
+        try if @next
+      }
+
+      self
+    end
+
+    alias and wait
+
+    def >>(*)
+      super.tap {
+        try
+      }
+    end
+
+    def try
+      if @wait.all?(&:realized?)
+        if promise = @wait.find(&:rejected?)
+          reject(promise.error)
+        else
+          resolve(@wait.map(&:value))
+        end
+      end
+    end
+  end
+end