opal-cj 0.7.0.beta1

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+require 'opal'
+require 'set'
+require 'opal-parser'
+require 'mspec'
+require 'mspec/version'
+require 'support/mspec_rspec_adapter'
+require 'mspec/opal/runner'
+
+require 'math'
+require 'encoding'
+
+ENV['MSPEC_RUNNER'] = true
+
+module Kernel
+  def opal_parse(str, file='(string)')
+    Opal::Parser.new.parse str, file
+  end
+
+  def eval_js(javascript)
+    `eval(javascript)`
+  end
+
+  def at_exit(&block)
+    $AT_EXIT_CALLBACKS ||= []
+    $AT_EXIT_CALLBACKS << block
+  end
+end
+
+if `!!window.OPAL_SPEC_PHANTOM`
+  require 'phantomjs'
+  formatter_class = PhantomFormatter
+else
+  formatter_class = BrowserFormatter
+end
+
+# Uncomment the following to see example titles when they're executed.
+# (useful to relate debug output to the example that generated it)
+#
+#formatter_class = PhantomDebugFormatter
+
+# As soon as this file loads, tell the runner the specs are starting
+OSpecRunner.main(formatter_class).will_start

data/spec/support/mspec_rspec_adapter.rb

@@ -0,0 +1,33 @@
+module MSpecRSpecAdapter
+  def expect(object)
+    MSpecRSpecAdapterShould.new(object)
+  end
+
+  def eq(expected)
+    MSpecRSpecAdapterEq.new(expected)
+  end
+
+  class MSpecRSpecAdapterEq < Struct.new(:object)
+  end
+
+  class MSpecRSpecAdapterShould < Struct.new(:object)
+    def to(expectation)
+      apply_expectation(:should, expectation)
+    end
+
+    def apply_expectation(type, expectation)
+      if MSpecRSpecAdapterEq === expectation
+        object.send(type) == expectation.object
+      else
+        object.send(type, expectation)
+      end
+    end
+
+    def not_to
+      apply_expectation(:should_not, expectation)
+    end
+    alias to_not not_to
+  end
+end
+
+include MSpecRSpecAdapter unless defined? RSpec

data/spec/support/parser_helpers.rb

@@ -0,0 +1,37 @@
+require 'opal/parser'
+
+module ParserHelpers
+  def parsed(source, file='(ParserHelpers:string)')
+    Opal::Parser.new.parse(source, file)
+  end
+
+  def expect_parsed(source)
+    expect(parsed(source))
+  end
+
+  def expect_parsed_string(source)
+    expect(parsed(source)[1])
+  end
+
+  def expect_lines(source)
+    expect(parsed_nodes(source).map { |sexp| sexp.line })
+  end
+
+  def expect_columns(source)
+    expect(parsed_nodes(source).map { |sexp| sexp.column })
+  end
+
+  def parsed_nodes(source)
+    parsed = Opal::Parser.new.parse(source)
+    parsed.type == :block ? parsed.children : [parsed]
+  end
+end
+
+if defined? RSpec
+  RSpec.configure do |config|
+    config.include ParserHelpers
+  end
+else
+  include ParserHelpers
+end
+

data/stdlib/README.md

@@ -0,0 +1,3 @@
+# Opal stdlib
+
+This is the Opal stdlib implementation API documentation.

data/stdlib/base64.rb

@@ -0,0 +1,152 @@
+module Base64
+  %x{
+    var charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+        lookup  = {};
+
+    for (var i = 0, length = charset.length; i < length; i++) {
+      lookup[charset.charAt(i)] = i;
+    }
+
+    function from(string) {
+      var buffer = [];
+
+      for (var i = 0, length = string.length; i < length; i++) {
+        var a, b, c, d;
+
+        a = lookup[string.charAt(i)];
+        b = lookup[string.charAt(++i)];
+
+        buffer.push((a << 2) | (b >> 4));
+
+        c = lookup[string.charAt(++i)];
+
+        if (c == 64) {
+          break;
+        }
+
+        buffer.push(((b & 15) << 4) | (c >> 2));
+
+        d = lookup[string.charAt(++i)];
+
+        if (d == 64) {
+          break;
+        }
+
+        buffer.push(((c & 3) << 6) | d);
+      }
+
+      return buffer;
+    }
+
+    function decode(string) {
+      var buffer = from(string),
+          result = [];
+
+      for (var i = 0, length = buffer.length; i < length; i++) {
+        if (buffer[i] < 128) {
+          result.push(String.fromCharCode(buffer[i]));
+        }
+        else if (buffer[i] > 191 && buffer[i] < 224) {
+          var a = (buffer[i] & 31) << 6,
+              b = buffer[++i] & 63;
+
+          result.push(String.fromCharCode(a | b));
+        }
+        else {
+          var a = (buffer[i] & 15) << 12,
+              b = (buffer[++i] & 63) << 6,
+              c = buffer[++i] & 63;
+
+          result.push(String.fromCharCode(a | b | c));
+        }
+      }
+
+      return result.join('');
+    }
+
+    function to(string) {
+      var buffer = [];
+
+      if (/^[\x00-\x7f]*$/.test(string)) {
+        for (var i = 0, length = string.length; i < length; i++) {
+          buffer.push(string.charCodeAt(i));
+        }
+      }
+      else {
+        for (var i = 0, length = string.length; i < length; i++) {
+          var ch = string.charCodeAt(i);
+
+          if (ch < 128) {
+            buffer.push(ch);
+          }
+          else if (ch < 2048) {
+            buffer.push((ch >> 6) | 192);
+            buffer.push((ch & 63) | 128);
+          }
+          else {
+            buffer.push((ch >> 12) | 224);
+            buffer.push(((ch >> 6) & 63) | 128);
+            buffer.push((ch & 63) | 128);
+          }
+        }
+      }
+
+      return buffer;
+    }
+
+    function encode(string) {
+      var buffer = to(string),
+          result = [];
+
+      for (var i = 0, length = buffer.length; i < length; i++) {
+        var a = buffer[i],
+            b = buffer[++i],
+            c = 0,
+            d = a >> 2,
+            e = ((a & 3) << 4) | (b >> 4),
+            f = 0,
+            g = 0;
+
+        if (isNaN(a)) {
+          f = g = 64;
+        }
+        else {
+          c = buffer[++i];
+          f = ((b & 15) << 2) | (c >> 6);
+          g = isNaN(c) ? 64 : c & 63;
+        }
+
+        result.push(charset.charAt(d));
+        result.push(charset.charAt(e));
+        result.push(charset.charAt(f));
+        result.push(charset.charAt(g));
+      }
+
+      return result.join('');
+    }
+  }
+
+  def self.decode64(string)
+    `decode(string.replace(/\r?\n/g, ''))`
+  end
+
+  def self.encode64(string)
+    `encode(string).replace(/(.{60})/g, "$1\n")`
+  end
+
+  def self.strict_decode64(string)
+    `decode(string)`
+  end
+
+  def self.strict_encode64(string)
+    `encode(string)`
+  end
+
+  def self.urlsafe_decode64(string)
+    `decode(string.replace(/\-/g, '+').replace(/_/g, '/'))`
+  end
+
+  def self.urlsafe_encode64(string)
+    `encode(string).replace(/\+/g, '-').replace(/\//g, '_')`
+  end
+end

data/stdlib/benchmark.rb

@@ -0,0 +1,10 @@
+module Benchmark
+
+  def measure(&block)
+    start = Time.now
+    yield
+    Time.now - start
+  end
+
+  module_function :measure
+end

data/stdlib/buffer.rb

@@ -0,0 +1,40 @@
+require 'buffer/array'
+require 'buffer/view'
+
+class Buffer
+  include Native
+
+  def self.supported?
+    not $$[:ArrayBuffer].nil?
+  end
+
+  def self.name_for(bits, type)
+    "#{case type
+      when :unsigned then 'Uint'
+      when :signed   then 'Int'
+      when :float    then 'Float'
+    end}#{bits}"
+  end
+
+  def initialize(size, bits = 8)
+    if native?(size)
+      super(size)
+    else
+      super(`new ArrayBuffer(size * (bits / 8))`)
+    end
+  end
+
+  def length
+    `#@native.byteLength`
+  end
+
+  alias size length
+
+  def to_a(bits = 8, type = :unsigned)
+    Array.new(self, bits, type)
+  end
+
+  def view(offset = nil, length = nil)
+    View.new(self, offset, length)
+  end
+end

data/stdlib/buffer/array.rb

@@ -0,0 +1,66 @@
+class Buffer < Native
+
+class Array < Native
+  def self.for(bits, type)
+    $$["#{Buffer.name_for bits, type}Array"]
+  end
+
+  include Enumerable
+
+  attr_reader :buffer, :type
+
+  def initialize(buffer, bits = nil, type = nil)
+    if Native == buffer
+      super(buffer)
+    else
+      %x{
+        var klass = #{Array.for(bits, type)};
+
+        #{super(`new klass(#{buffer.to_n})`)}
+      }
+    end
+
+    @buffer = buffer
+    @type   = type
+  end
+
+  def bits
+    `#@native.BYTES_PER_ELEMENT * 8`
+  end
+
+  def [](index, offset = nil)
+    offset ? `#@native.subarray(index, offset)` : `#@native[index]`
+  end
+
+  def []=(index, value)
+    `#@native[index] = value`
+  end
+
+  def bytesize
+    `#@native.byteLength`
+  end
+
+  def each
+    return enum_for :each unless block_given?
+
+    %x{
+      for (var i = 0, length = #@native.length; i < length; i++) {
+        #{yield `#@native[i]`}
+      }
+    }
+
+    self
+  end
+
+  def length
+    `#@native.length`
+  end
+
+  def merge!(other, offset = undefined)
+    `#@native.set(#{other.to_n}, offset)`
+  end
+
+  alias size length
+end
+
+end

data/stdlib/buffer/view.rb

@@ -0,0 +1,70 @@
+class Buffer
+
+class View
+  include Native
+
+  def self.supported?
+    not $$[:DataView].nil?
+  end
+
+  attr_reader :buffer, :offset
+
+  def initialize(buffer, offset = nil, length = nil)
+    if native?(buffer)
+      super(buffer)
+    elsif offset && length
+      super(`new DataView(#{buffer.to_n}, #{offset.to_n}, #{length.to_n})`)
+    elsif offset
+      super(`new DataView(#{buffer.to_n}, #{offset.to_n})`)
+    else
+      super(`new DataView(#{buffer.to_n})`)
+    end
+
+    @buffer = buffer
+    @offset = offset
+  end
+
+  def length
+    `#@native.byteLength`
+  end
+
+  alias size length
+
+  def get(offset, bits = 8, type = :unsigned, little = false)
+    `#@native["get" + #{Buffer.name_for bits, type}](offset, little)`
+  end
+
+  alias [] get
+
+  def set(offset, value, bits = 8, type = :unsigned, little = false)
+    `#@native["set" + #{Buffer.name_for bits, type}](offset, value, little)`
+  end
+
+  alias []= set
+
+  def get_int8(offset, little = false); `#@native.getInt8(offset, little)`; end
+  def set_int8(offset, value, little = false); `#@native.setInt8(offset, value, little)`; end
+
+  def get_uint8(offset, little = false); `#@native.getUint8(offset, little)`; end
+  def set_uint8(offset, value, little = false); `#@native.setUint8(offset, value, little)`; end
+
+  def get_int16(offset, little = false); `#@native.getInt16(offset, little)`; end
+  def set_int16(offset, value, little = false); `#@native.setInt16(offset, value, little)`; end
+
+  def get_uint16(offset, little = false); `#@native.getUint16(offset, little)`; end
+  def set_uint16(offset, value, little = false); `#@native.setUint16(offset, value, little)`; end
+
+  def get_int32(offset, little = false); `#@native.getInt32(offset, little)`; end
+  def set_int32(offset, value, little = false); `#@native.setInt32(offset, value, little)`; end
+
+  def get_uint32(offset, little = false); `#@native.getUint32(offset, little)`; end
+  def set_uint32(offset, value, little = false); `#@native.setUint32(offset, value, little)`; end
+
+  def get_float32(offset, little = false); `#@native.getFloat32(offset, little)`; end
+  def set_float32(offset, value, little = false); `#@native.setFloat32(offset, value, little)`; end
+
+  def get_float64(offset, little = false); `#@native.getFloat64(offset, little)`; end
+  def set_float64(offset, value, little = false); `#@native.setFloat64(offset, value, little)`; end
+end
+
+end