opal 0.9.4 → 0.10.0.beta1

data/spec/spec_helper.rb

@@ -4,10 +4,10 @@ require 'opal-parser'
 require 'mspec'
 require 'mspec/version'
 require 'support/mspec_rspec_adapter'
-require 'mspec/opal/runner'
+require 'mspec-opal/runner'
 
 # 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)
+# showed to need more tolerance (ruby spec default is 0.00003)
 TOLERANCE = 0.00004
 
 ENV['MSPEC_RUNNER'] = true
@@ -23,16 +23,4 @@ module Kernel
 end
 
 require 'mspec/utils/script' # Needed by DottedFormatter
-formatter_class = DottedFormatter
-
-require 'mspec/opal/formatters'
-# Uncomment one of the following to use a different formatter:
-#
-#formatter_class = BrowserFormatter
-#formatter_class = NodeJSFormatter
-#formatter_class = NodeJSDocFormatter
-#formatter_class = PhantomFormatter
-#formatter_class = PhantomDocFormatter
-
-# As soon as this file loads, tell the runner the specs are starting
-OSpecRunner.main(formatter_class).will_start
+require 'mspec-opal/formatters'

data/stdlib/base64.rb

@@ -1,129 +1,59 @@
 module Base64
+  # FROM https://github.com/davidchambers/Base64.js/blob/69262ec7e1fa4541de5700a1b0b03b0de0e3f5aa/base64.js
   %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));
+    var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+    var encode, decode;
+
+    // encoder
+    // [https://gist.github.com/999166] by [https://github.com/nignag]
+    encode = Opal.global.btoa || function (input) {
+      var str = String(input);
+      /* jshint ignore:start */
+      for (
+        // initialize result and counter
+        var block, charCode, idx = 0, map = chars, output = '';
+        // if the next str index does not exist:
+        //   change the mapping table to "="
+        //   check if d has no fractional digits
+        str.charAt(idx | 0) || (map = '=', idx % 1);
+        // "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8
+        output += map.charAt(63 & block >> 8 - idx % 1 * 8)
+      ) {
+        charCode = str.charCodeAt(idx += 3/4);
+        if (charCode > 0xFF) {
+          #{raise ArgumentError, 'invalid character (failed: The string to be encoded contains characters outside of the Latin1 range.)'};
         }
+        block = block << 8 | charCode;
       }
-
-      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 output;
+      /* jshint ignore:end */
+    };
+
+    // decoder
+    // [https://gist.github.com/1020396] by [https://github.com/atk]
+    decode = Opal.global.atob || function (input) {
+      var str = String(input).replace(/=+$/, '');
+      if (str.length % 4 == 1) {
+        #{raise ArgumentError, 'invalid base64 (failed: The string to be decoded is not correctly encoded.)'};
       }
-
-      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));
+      /* jshint ignore:start */
+      for (
+        // initialize result and counters
+        var bc = 0, bs, buffer, idx = 0, output = '';
+        // get next character
+        buffer = str.charAt(idx++);
+        // character found in table? initialize bit storage and add its ascii value;
+        ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,
+          // and if not first of each 4 characters,
+          // convert the first 8 bits to one ascii character
+          bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0
+      ) {
+        // try to find character in table (0-63, not found => -1)
+        buffer = chars.indexOf(buffer);
       }
-
-      return result.join('');
-    }
+      return output;
+      /* jshint ignore:end */
+    };
   }
 
   def self.decode64(string)
@@ -131,7 +61,7 @@ module Base64
   end
 
   def self.encode64(string)
-    `encode(string).replace(/(.{60})/g, "$1\n")`
+    `encode(string).replace(/(.{60})/g, "$1\n").replace(/([^\n])$/g, "$1\n")`
   end
 
   def self.strict_decode64(string)

data/stdlib/bigdecimal.rb

@@ -0,0 +1,231 @@
+class BigDecimal < Numeric; end
+
+require 'js'
+require 'bigdecimal/kernel'
+require 'bigdecimal/bignumber.js'
+
+class BigDecimal
+  ROUND_MODE = 256
+
+  # NOTE: the numeric values of the ROUND_* constants
+  # follow BigNumber.js, they are NOT the same as MRI
+  ROUND_UP = 0
+  ROUND_DOWN = 1
+  ROUND_CEILING = 2
+  ROUND_FLOOR = 3
+  ROUND_HALF_UP = 4
+  ROUND_HALF_DOWN = 5
+  ROUND_HALF_EVEN = 6
+
+  SIGN_NaN = 0
+  SIGN_POSITIVE_ZERO = 1
+  SIGN_NEGATIVE_ZERO = -1
+  SIGN_POSITIVE_FINITE = 2
+  SIGN_NEGATIVE_FINITE = -2
+  SIGN_POSITIVE_INFINITE = 3
+  SIGN_NEGATIVE_INFINITE = -3
+
+  def self.limit(digits = nil)
+    @digits = digits if digits
+    @digits
+  end
+
+  def self.mode(mode, value = nil)
+    case mode
+    when ROUND_MODE
+      @round_mode = value if value
+      @round_mode || ROUND_HALF_UP
+    end
+  end
+
+  attr_reader :bignumber
+
+  def initialize(initial, digits = 0)
+    @bignumber = JS.new(BigNumber, initial)
+  end
+
+  def ==(other)
+    case other
+    when self.class
+      bignumber.JS.equals(other.bignumber)
+    when Number
+      bignumber.JS.equals(other)
+    else
+      false
+    end
+  end
+
+  alias === ==
+
+  def <=>(other)
+    case other
+    when self.class
+      result = bignumber.JS.comparedTo(other.bignumber)
+    when Number
+      result = bignumber.JS.comparedTo(other)
+    else
+      result = nil
+    end
+    `#{result} === null ? nil : #{result}`
+  end
+
+  def <(other)
+    return false if nan? || other && other.nan?
+    super
+  end
+
+  def <=(other)
+    return false if nan? || other && other.nan?
+    super
+  end
+
+  def >(other)
+    return false if nan? || other && other.nan?
+    super
+  end
+
+  def >=(other)
+    return false if nan? || other && other.nan?
+    super
+  end
+
+  def abs
+    self.class.new(bignumber.JS.abs)
+  end
+
+  def add(other, digits = 0)
+    if digits == nil
+      raise TypeError, 'wrong argument type nil (expected Fixnum)'
+    end
+
+    if digits < 0
+      raise ArgumentError, 'argument must be positive'
+    end
+
+    other, _ = coerce(other)
+
+    result = bignumber.JS.plus(other.bignumber)
+
+    if digits > 0
+      result = result.JS.toDigits(digits, self.class.mode(ROUND_MODE))
+    end
+
+    self.class.new(result)
+  end
+
+  alias + add
+
+  def ceil(n = nil)
+    unless bignumber.JS.isFinite
+      raise FloatDomainError, "Computation results to 'Infinity'"
+    end
+
+    if n == nil
+      bignumber.JS.round(0, ROUND_CEILING).JS.toNumber
+    elsif n >= 0
+      self.class.new(bignumber.JS.round(n, ROUND_CEILING))
+    else
+      self.class.new(bignumber.JS.round(0, ROUND_CEILING))
+    end
+  end
+
+  def coerce(other)
+    case other
+    when self.class
+      [other, self]
+    when Number
+      [self.class.new(other), self]
+    else
+      raise TypeError, "#{other.class} can't be coerced into #{self.class}"
+    end
+  end
+
+  def div(other, digits = nil)
+    return self / other if digits == 0
+
+    other, _ = coerce(other)
+
+    if nan? || other.nan?
+      raise FloatDomainError, "Computation results to 'NaN'(Not a Number)"
+    end
+
+    if digits == nil
+      if other.zero?
+        raise ZeroDivisionError, "divided by 0"
+      end
+
+      if infinite?
+        raise FloatDomainError, "Computation results to 'Infinity'"
+      end
+
+      return self.class.new(bignumber.JS.dividedToIntegerBy(other.bignumber))
+    end
+
+    self.class.new(bignumber.JS.dividedBy(other.bignumber).JS.round(digits, self.class.mode(ROUND_MODE)))
+  end
+
+  def finite?
+    bignumber.JS.isFinite
+  end
+
+  def infinite?
+    return nil if finite? || nan?
+    bignumber.JS.isNegative ? -1 : 1
+  end
+
+  def minus(other)
+    other, _ = coerce(other)
+    self.class.new(bignumber.JS.minus(other.bignumber))
+  end
+
+  alias - minus
+
+  def mult(other, digits = nil)
+    other, _ = coerce(other)
+
+    if digits == nil
+      return self.class.new(bignumber.JS.times(other.bignumber))
+    end
+
+    self.class.new(bignumber.JS.times(other.bignumber).JS.round(digits, self.class.mode(ROUND_MODE)))
+  end
+
+  alias * mult
+
+  def nan?
+    bignumber.JS.isNaN
+  end
+
+  def quo(other)
+    other, _ = coerce(other)
+    self.class.new(bignumber.JS.dividedBy(other.bignumber))
+  end
+
+  alias / quo
+
+  def sign
+    if bignumber.JS.isNaN
+      return SIGN_NaN
+    end
+    if bignumber.JS.isZero
+      return bignumber.JS.isNegative ? SIGN_NEGATIVE_ZERO : SIGN_POSITIVE_ZERO
+    end
+  end
+
+  def sub(other, precision)
+    other, _ = coerce(other)
+    self.class.new(bignumber.JS.minus(other.bignumber))
+  end
+
+  def to_f
+    bignumber.JS.toNumber
+  end
+
+  def to_s(s = '')
+    bignumber.JS.toString
+  end
+
+  def zero?
+    bignumber.JS.isZero
+  end
+end