opal-wedge 0.9.0.dev

data/spec/opal/stdlib/thread/mutex_spec.rb

@@ -0,0 +1,40 @@
+require 'thread'
+
+describe Mutex do
+  before do
+    @mutex = Mutex.new
+  end
+
+  it "cannot be locked twice" do
+    @mutex.lock
+    lambda do
+      @mutex.lock
+    end.should raise_error(ThreadError)
+  end
+
+  it "reports locked? status" do
+    @mutex.locked?.should be_false
+    @mutex.lock
+    @mutex.locked?.should be_true
+  end
+
+  it "reports locked? status with try_lock" do
+    @mutex.try_lock.should be_true
+    @mutex.locked?.should be_true
+    @mutex.try_lock.should be_false
+  end
+
+  it "is locked and unlocked by synchronize" do
+    @mutex.synchronize do
+      @mutex.locked?.should be_true
+    end
+    @mutex.locked?.should be_false
+  end
+
+  it "will not be locked by synchronize if already locked" do
+    @mutex.lock
+    lambda do
+      @mutex.synchronize {}
+    end.should raise_error(ThreadError)
+  end
+end

data/spec/opal/stdlib/thread/thread_queue_spec.rb

@@ -0,0 +1,32 @@
+require 'thread'
+
+describe Thread::Queue do
+  before do
+    @queue = Thread::Queue.new
+  end
+
+  it "is aliased as ::Queue" do
+    ::Thread::Queue.should == ::Queue
+  end
+
+  it "will not allow deadlock" do
+    lambda do
+      @queue.pop
+    end.should raise_error(ThreadError)
+  end
+
+  it "pops in FIFO order" do
+    @queue.push(1)
+    @queue.push(2)
+
+    @queue.pop.should == 1
+    @queue.pop.should == 2
+  end
+
+  it "can be cleared by clear" do
+    @queue.push(1)
+    @queue.clear
+    @queue.size.should == 0
+    @queue.empty?.should be_true
+  end
+end

data/spec/opal/stdlib/thread/thread_spec.rb

@@ -0,0 +1,60 @@
+require 'thread'
+
+# Our implementation of Thread only supports faux thread-local variables.
+# Since we can't actually create a thread, nothing in rubyspec will run.
+describe Thread do
+  it "returns a value for current" do
+    Thread.current.should_not be_nil
+  end
+
+  it "only has current in list" do
+    Thread.list.should == [Thread.current]
+  end
+
+  it "does not allow creation of new threads" do
+    lambda do
+      Thread.new {}
+    end.should raise_error(NotImplementedError)
+  end
+
+  describe "local storage" do
+    before do
+      @current = Thread.current
+      @current.send(:core_initialize!)
+    end
+
+    it "stores fiber-local variables" do
+      @current[:a] = 'hello'
+      @current[:a].should == 'hello'
+    end
+
+    it "returns fiber-local keys that are assigned" do
+      @current[:a] = 'hello'
+      @current.key?(:a).should be_true
+      @current.keys.should === ['a']
+    end
+
+    it "considers fiber-local keys, as symbols or strings equal" do
+      @current[:a]  = 1
+      @current['a'] = 2
+      @current.keys.size.should == 1
+      @current[:a].should == 2
+    end
+
+    it "implements thread-local variables" do
+      @current.thread_variable_set('a', 1)
+      @current.thread_variable_get('a').should == 1
+      @current.thread_variables.should == ['a']
+    end
+
+    it "distinguishes between fiber-local and thread-local variables" do
+      @current[:a] = 1
+      @current.thread_variables.should == []
+
+      @current.thread_variable_set(:a, 2)
+
+      @current[:a].should == 1
+      @current.thread_variable_get(:a).should == 2
+    end
+  end
+end

data/spec/rubyspecs

@@ -0,0 +1,144 @@
+rubyspec/core/array
+rubyspec/core/basicobject
+rubyspec/core/builtin_constants
+rubyspec/core/class
+rubyspec/core/comparable
+rubyspec/core/enumerable
+rubyspec/core/enumerator
+
+rubyspec/core/exception
+!rubyspec/core/exception/load_error_spec
+
+rubyspec/core/false
+rubyspec/core/fixnum
+rubyspec/core/float
+rubyspec/core/hash
+
+rubyspec/core/integer
+!rubyspec/core/integer/times_spec
+
+rubyspec/core/kernel
+!rubyspec/core/kernel/abort_spec
+!rubyspec/core/kernel/at_exit_spec
+!rubyspec/core/kernel/autoload_spec
+!rubyspec/core/kernel/backtick_spec
+!rubyspec/core/kernel/binding_spec
+!rubyspec/core/kernel/callcc_spec
+!rubyspec/core/kernel/caller_locations_spec
+!rubyspec/core/kernel/caller_spec
+!rubyspec/core/kernel/catch_spec
+!rubyspec/core/kernel/chomp_spec
+!rubyspec/core/kernel/chop_spec
+!rubyspec/core/kernel/exec_spec
+!rubyspec/core/kernel/exit_spec
+!rubyspec/core/kernel/extend_spec
+!rubyspec/core/kernel/fail_spec
+!rubyspec/core/kernel/fork_spec
+!rubyspec/core/kernel/gets_spec
+!rubyspec/core/kernel/load_spec
+!rubyspec/core/kernel/open_spec
+!rubyspec/core/kernel/putc_spec
+!rubyspec/core/kernel/raise_spec
+!rubyspec/core/kernel/readline_spec
+!rubyspec/core/kernel/readlines_spec
+!rubyspec/core/kernel/require_relative_spec
+!rubyspec/core/kernel/require_spec
+!rubyspec/core/kernel/select_spec
+!rubyspec/core/kernel/set_trace_func_spec
+!rubyspec/core/kernel/spawn_spec
+!rubyspec/core/kernel/syscall_spec
+!rubyspec/core/kernel/system_spec
+!rubyspec/core/kernel/taint_spec
+!rubyspec/core/kernel/tainted_spec
+!rubyspec/core/kernel/test_spec
+!rubyspec/core/kernel/throw_spec
+!rubyspec/core/kernel/trace_var_spec
+!rubyspec/core/kernel/trap_spec
+!rubyspec/core/kernel/trust_spec
+!rubyspec/core/kernel/untaint_spec
+!rubyspec/core/kernel/untrace_var_spec
+!rubyspec/core/kernel/untrust_spec
+!rubyspec/core/kernel/untrusted_spec
+
+rubyspec/core/matchdata
+rubyspec/core/math
+
+# rubyspec/core/method - cannot parse `def one_splat_one_req(*a,b); end`
+
+rubyspec/core/module
+!rubyspec/core/module/autoload_spec
+!rubyspec/core/module/const_defined_spec
+!rubyspec/core/module/const_set_spec
+!rubyspec/core/module/name_spec
+
+rubyspec/core/nil
+rubyspec/core/numeric
+
+rubyspec/core/proc
+!rubyspec/core/proc/arity_spec
+!rubyspec/core/proc/parameters_spec
+
+rubyspec/core/range
+!rubyspec/core/range/to_a_spec
+
+rubyspec/core/regexp
+!rubyspec/core/regexp/named_captures_spec
+!rubyspec/core/regexp/names_spec
+!rubyspec/core/regexp/encoding_spec
+!rubyspec/core/regexp/fixed_encoding_spec
+
+rubyspec/core/string
+!rubyspec/core/string/crypt_spec
+!rubyspec/core/string/scrub_spec
+
+rubyspec/core/struct
+rubyspec/core/symbol/to_proc_spec
+
+rubyspec/core/time
+!rubyspec/core/time/_dump_spec
+!rubyspec/core/time/_load_spec
+
+rubyspec/core/true
+
+rubyspec/core/unboundmethod
+!rubyspec/core/unboundmethod/arity_spec
+
+rubyspec/language
+!rubyspec/language/block_spec
+!rubyspec/language/break_spec
+!rubyspec/language/constants_spec
+!rubyspec/language/def_spec
+!rubyspec/language/encoding_spec
+!rubyspec/language/execution_spec
+!rubyspec/language/hash_spec
+!rubyspec/language/line_spec
+!rubyspec/language/lambda_spec
+!rubyspec/language/match_spec
+!rubyspec/language/method_spec
+!rubyspec/language/module_spec
+!rubyspec/language/next_spec
+!rubyspec/language/predefined_spec
+!rubyspec/language/proc_spec
+!rubyspec/language/regexp_spec
+!rubyspec/language/return_spec
+!rubyspec/language/send_spec
+!rubyspec/language/splat_spec
+!rubyspec/language/string_spec
+!rubyspec/language/symbol_spec
+!rubyspec/language/throw_spec
+!rubyspec/language/variables_spec
+!rubyspec/language/while_spec
+!rubyspec/language/yield_spec
+
+rubyspec/library/date
+
+rubyspec/library/delegate/delegator/send_spec
+
+rubyspec/library/erb/util/h_spec
+rubyspec/library/erb/util/html_escape_spec
+
+rubyspec/library/observer
+rubyspec/library/pathname
+rubyspec/library/set
+rubyspec/library/singleton
+rubyspec/library/stringscanner

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+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'
+
+# Node v0.12 as well as Google Chrome/V8 42.0.2311.135 (64-bit)
+# showed to need more tolerance (rubyspec default is 0.00003)
+TOLERANCE = 0.00004
+
+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
+
+is_node = `typeof(process) == 'object' && !!process.versions.node`
+is_browser = `(typeof(window) !== 'undefined')`
+is_phantom = is_browser && `!!window.OPAL_SPEC_PHANTOM`
+
+case
+when is_node
+  formatter_class = NodeJSFormatter
+when is_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 = [], a, b, c;
+
+      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) {
+          a = (buffer[i] & 31) << 6;
+          b = buffer[++i] & 63;
+
+          result.push(String.fromCharCode(a | b));
+        }
+        else {
+          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 = [], i, length;
+
+      if (/^[\x00-\x7f]*$/.test(string)) {
+        for (i = 0, length = string.length; i < length; i++) {
+          buffer.push(string.charCodeAt(i));
+        }
+      }
+      else {
+        for (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