opal 0.8.1 → 0.9.0.beta1

data/stdlib/console.rb

@@ -0,0 +1,94 @@
+require 'native'
+
+# Manipulate the browser console.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/console
+class Console
+  include Native
+
+  # Clear the console.
+  def clear
+    `#@native.clear()`
+  end
+
+  # Print a stacktrace from the call site.
+  def trace
+    `#@native.trace()`
+  end
+
+  # Log the passed objects based on an optional initial format.
+  def log(*args)
+    `#@native.log.apply(#@native, args)`
+  end
+
+  # Log the passed objects based on an optional initial format as informational
+  # log.
+  def info(*args)
+    `#@native.info.apply(#@native, args)`
+  end
+
+  # Log the passed objects based on an optional initial format as warning.
+  def warn(*args)
+    `#@native.warn.apply(#@native, args)`
+  end
+
+  # Log the passed objects based on an optional initial format as error.
+  def error(*args)
+    `#@native.error.apply(#@native, args)`
+  end
+
+  # Time the given block with the given label.
+  def time(label, &block)
+    raise ArgumentError, "no block given" unless block
+
+    `#@native.time(label)`
+
+    begin
+      if block.arity == 0
+        instance_exec(&block)
+      else
+        block.call(self)
+      end
+    ensure
+      `#@native.timeEnd()`
+    end
+  end
+
+  # Group the given block.
+  def group(*args, &block)
+    raise ArgumentError, "no block given" unless block
+
+    `#@native.group.apply(#@native, args)`
+
+    begin
+      if block.arity == 0
+        instance_exec(&block)
+      else
+        block.call(self)
+      end
+    ensure
+      `#@native.groupEnd()`
+    end
+  end
+
+  # Group the given block but collapse it.
+  def group!(*args, &block)
+    return unless block_given?
+
+    `#@native.groupCollapsed.apply(#@native, args)`
+
+    begin
+      if block.arity == 0
+        instance_exec(&block)
+      else
+        block.call(self)
+      end
+    ensure
+      `#@native.groupEnd()`
+    end
+  end
+end
+
+if defined?(`Opal.global.console`)
+  $console = Console.new(`Opal.global.console`)
+end

data/stdlib/date.rb

@@ -10,7 +10,7 @@ class Date
 
     def parse(string)
       match = `/^(\d*)-(\d*)-(\d*)/.exec(string)`
-      wrap `new Date(parseInt(match[1]), parseInt(match[2]) - 1, parseInt(match[3]))`
+      wrap `new Date(parseInt(match[1], 10), parseInt(match[2], 10) - 1, parseInt(match[3], 10))`
     end
 
     def today

data/stdlib/encoding.rb

@@ -1,170 +1 @@
-require 'corelib/string'
-
-class Encoding
-  def self.register(name, options = {}, &block)
-    names    = [name] + (options[:aliases] || [])
-    encoding = Class.new(self, &block).
-      new(name, names, options[:ascii] || false, options[:dummy] || false)
-
-    names.each {|name|
-      const_set name.sub('-', '_'), encoding
-    }
-  end
-
-  def self.find(name)
-    upcase_name = name.upcase
-    return upcase_name if self === upcase_name
-
-    constants.each {|const|
-      encoding = const_get(const)
-
-      if encoding.name == upcase_name || encoding.names.include?(upcase_name)
-        return encoding
-      end
-    }
-
-    raise ArgumentError, "unknown encoding name - #{name}"
-  end
-
-  class << self
-    attr_accessor :default_external
-  end
-
-  attr_reader :name, :names
-
-  def initialize(name, names, ascii, dummy)
-    @name  = name
-    @names = names
-    @ascii = ascii
-    @dummy = dummy
-  end
-
-  def ascii_compatible?
-    @ascii
-  end
-
-  def dummy?
-    @dummy
-  end
-
-  def to_s
-    @name
-  end
-
-  def inspect
-    "#<Encoding:#{@name}#{" (dummy)" if @dummy}>"
-  end
-
-  # methods to implement per encoding
-  def each_byte(*)
-    raise NotImplementedError
-  end
-
-  def getbyte(*)
-    raise NotImplementedError
-  end
-
-  def bytesize(*)
-    raise NotImplementedError
-  end
-
-  class EncodingError < StandardError; end
-  class CompatibilityError < EncodingError; end
-end
-
-Encoding.register "UTF-8", aliases: ["CP65001"], ascii: true do
-  def each_byte(string, &block)
-    %x{
-      for (var i = 0, length = string.length; i < length; i++) {
-        var code = string.charCodeAt(i);
-
-        if (code <= 0x7f) {
-          #{yield `code`};
-        }
-        else {
-          var encoded = encodeURIComponent(string.charAt(i)).substr(1).split('%');
-
-          for (var j = 0, encoded_length = encoded.length; j < encoded_length; j++) {
-            #{yield `parseInt(encoded[j], 16)`};
-          }
-        }
-      }
-    }
-  end
-
-  def bytesize
-    bytes.length
-  end
-end
-
-Encoding.register "UTF-16LE" do
-  def each_byte(string, &block)
-    %x{
-      for (var i = 0, length = string.length; i < length; i++) {
-        var code = string.charCodeAt(i);
-
-        #{yield `code & 0xff`};
-        #{yield `code >> 8`};
-      }
-    }
-  end
-
-  def bytesize
-    bytes.length
-  end
-end
-
-Encoding.register "ASCII-8BIT", aliases: ["BINARY"], ascii: true do
-  def each_byte(string, &block)
-    %x{
-      for (var i = 0, length = string.length; i < length; i++) {
-        #{yield `string.charCodeAt(i) & 0xff`};
-      }
-    }
-  end
-
-  def bytesize
-    bytes.length
-  end
-end
-
-class String
-  `def.encoding = #{Encoding::UTF_16LE}`
-
-  def bytes
-    each_byte.to_a
-  end
-
-  def bytesize
-    @encoding.bytesize(self)
-  end
-
-  def each_byte(&block)
-    return enum_for :each_byte unless block_given?
-
-    @encoding.each_byte(self, &block)
-
-    self
-  end
-
-  def encoding
-    @encoding
-  end
-
-  def force_encoding(encoding)
-    encoding = Encoding.find(encoding)
-
-    return self if encoding == @encoding
-
-    %x{
-      var result = new String(self);
-      result.encoding = encoding;
-
-      return result;
-    }
-  end
-
-  def getbyte(idx)
-    @encoding.getbyte(self, idx)
-  end
-end
+warn "DEPRECATION: encoding is now part of the core library, requiring it is deprecated"

data/stdlib/js.rb

@@ -0,0 +1,56 @@
+# The JS module provides syntax sugar for calling native javascript
+# operators (e.g. typeof, instanceof, new, delete) and global functions
+# (e.g. parseFloat, parseInt).
+module JS
+  # Use delete to remove a property from an object.
+  def delete(object, property)
+    `delete #{object}[#{property}]`
+  end
+
+  # The global object
+  def global
+    `Opal.global`
+  end
+
+  # Use in to check for a property in an object.
+  def in(property, object)
+    `#{property} in #{object}`
+  end
+
+  # Use instanceof to return whether value is an instance of the function.
+  def instanceof(value, func)
+    `#{value} instanceof #{func}`
+  end
+
+  # Use new to create a new instance of the prototype of the function.
+  def new(func, *args, &block)
+    args << block if block
+    f = `function(){return func.apply(this, args)}`
+    f.JS[:prototype] = func.JS[:prototype]
+    `new f()`
+  end
+
+  # Use typeof to return the underlying javascript type of value.
+  # Note that for undefined values, this will not work exactly like
+  # the javascript typeof operator, as the argument is evaluated before
+  # the function call.
+  def typeof(value)
+    `typeof #{value}`
+  end
+
+  # Use void to return undefined.
+  def void(expr)
+    # Could use `undefined` here, but this is closer to the intent of the method
+    `void #{expr}`
+  end
+
+  # Call the global javascript function with the given arguments.
+  def call(func, *args, &block)
+    g = global
+    args << block if block
+    g.JS[func].JS.apply(g, args)
+  end
+  alias method_missing call
+
+  extend self
+end

data/stdlib/json.rb

@@ -40,7 +40,7 @@ module JSON
 
             var klass;
             if ((klass = #{`hash`[JSON.create_id]}) != nil) {
-              klass = Opal.cget(klass);
+              klass = Opal.get(klass);
               return #{`klass`.json_create(`hash`)};
             }
             else {
@@ -136,27 +136,22 @@ end
 class Hash
   def to_json
     %x{
-      var inspect = [],
-          keys = self.keys,
-          _map = self.map,
-          smap = self.smap,
-          map, khash;
+      var result = [];
 
-      for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i];
+      for (var i = 0, keys = self.keys, length = keys.length, key, value; i < length; i++) {
+        key = keys[i];
 
         if (key.$$is_string) {
-          map = smap;
-          khash = key;
+          value = self.smap[key];
         } else {
-          map = _map;
-          khash = key.$hash();
+          value = key.value;
+          key = key.key;
         }
 
-        inspect.push(#{`key`.to_s.to_json} + ':' + #{`map[khash]`.to_json});
+        result.push(#{`key`.to_s.to_json} + ':' + #{`value`.to_json});
       }
 
-      return '{' + inspect.join(', ') + '}';
+      return '{' + result.join(', ') + '}';
     }
   end
 end

data/stdlib/math.rb

@@ -1,370 +1 @@
-module Math
-  class DomainError < StandardError
-    def self.new(method)
-      super "Numerical argument is out of domain - \"#{method}\""
-    end
-  end
-
-  E  = `Math.E`
-  PI = `Math.PI`
-
-  def acos(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      x = #{x.to_f};
-
-      if (x < -1 || x > 1) {
-        #{raise DomainError, :acos};
-      }
-
-      return Math.acos(x);
-    }
-  end
-
-  unless defined?(`Math.acosh`)
-    %x{
-      Math.acosh = function(x) {
-        return Math.log(x + Math.sqrt(x * x - 1));
-      }
-    }
-  end
-
-  def acosh(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      return Math.acosh(#{x.to_f});
-    }
-  end
-
-  def asin(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      x = #{x.to_f};
-
-      if (x < -1 || x > 1) {
-        #{raise DomainError, :asin};
-      }
-
-      return Math.asin(x);
-    }
-  end
-
-  unless defined?(`Math.asinh`)
-    %x{
-      Math.asinh = function(x) {
-        return Math.log(x + Math.sqrt(x * x + 1))
-      }
-    }
-  end
-
-  def asinh(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      return Math.asinh(#{x.to_f});
-    }
-  end
-
-  def atan(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      return Math.atan(#{x.to_f});
-    }
-  end
-
-  def atan2(x, y)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      if (!#{Numeric === y}) {
-        #{raise Opal.type_error(y, Float)};
-      }
-
-      return Math.atan2(#{x.to_f}, #{y.to_f});
-    }
-  end
-
-  unless defined?(`Math.atanh`)
-    %x{
-      Math.atanh = function(x) {
-        return 0.5 * Math.log((1 + x) / (1 - x));
-      }
-    }
-  end
-
-  def atanh(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      x = #{x.to_f};
-
-      if (x < -1 || x > 1) {
-        #{raise DomainError, :atanh};
-      }
-
-      return Math.atanh(x);
-    }
-  end
-
-  # TODO: reimplement this when unavailable
-  def cbrt(x)
-    `Math.cbrt(x)`
-  end
-
-  def cos(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      return Math.cos(#{x.to_f});
-    }
-  end
-
-  unless defined?(`Math.cosh`)
-    %x{
-      Math.cosh = function(x) {
-        return (Math.exp(x) + Math.exp(-x)) / 2;
-      }
-    }
-  end
-
-  def cosh(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      return Math.cosh(#{x.to_f});
-    }
-  end
-
-  def erf(x)
-    raise NotImplementedError
-  end
-
-  def erfc(x)
-    raise NotImplementedError
-  end
-
-  def exp(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      return Math.exp(#{x.to_f});
-    }
-  end
-
-  def frexp(x)
-    raise NotImplementedError
-  end
-
-  def gamma(x)
-    raise NotImplementedError
-  end
-
-  unless defined?(`Math.hypot`)
-    %x{
-      Math.hypot = function(x, y) {
-        return Math.sqrt(x * x + y * y)
-      }
-    }
-  end
-
-  def hypot(x, y)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      if (!#{Numeric === y}) {
-        #{raise Opal.type_error(y, Float)};
-      }
-
-      return Math.hypot(#{x.to_f}, #{y.to_f});
-    }
-  end
-
-  def ldexp(flt, int)
-    raise NotImplementedError
-  end
-
-  def lgamma(x)
-    raise NotImplementedError
-  end
-
-  def log(num, base = E, method = nil)
-    %x{
-      if (!#{Numeric === num}) {
-        #{raise Opal.type_error(num, Float)};
-      }
-
-      if (!#{Numeric === base}) {
-        #{raise Opal.type_error(base, Float)};
-      }
-
-      num  = #{num.to_f};
-      base = #{base.to_f};
-
-      if (num < 0) {
-        #{raise DomainError, method || :log};
-      }
-
-      num = Math.log(num);
-
-      if (base != Math.E) {
-        num /= Math.log(base);
-      }
-
-      return num
-    }
-  end
-
-  if defined?(`Math.log10`)
-    def log10(num)
-      %x{
-        if (!#{Numeric === num}) {
-          #{raise Opal.type_error(num, Float)};
-        }
-
-        num = #{num.to_f};
-
-        if (num < 0) {
-          #{raise DomainError, :log2};
-        }
-
-        return Math.log10(num);
-      }
-    end
-  else
-    def log10(num)
-      log(num, 10, :log10)
-    end
-  end
-
-  if defined?(`Math.log2`)
-    def log2(num)
-      %x{
-        if (!#{Numeric === num}) {
-          #{raise Opal.type_error(num, Float)};
-        }
-
-        num = #{num.to_f};
-
-        if (num < 0) {
-          #{raise DomainError, :log2};
-        }
-
-        return Math.log2(num);
-      }
-    end
-  else
-    def log2(num)
-      log(num, 2, :log2)
-    end
-  end
-
-  def sin(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      return Math.sin(#{x.to_f});
-    }
-  end
-
-  unless defined?(`Math.sinh`)
-    %x{
-      Math.sinh = function(x) {
-        return (Math.exp(x) - Math.exp(-x)) / 2;
-      }
-    }
-  end
-
-  def sinh(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      return Math.sinh(#{x.to_f});
-    }
-  end
-
-  def sqrt(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      x = #{x.to_f};
-
-      if (x < 0) {
-        #{raise DomainError, :log2};
-      }
-
-      return Math.sqrt(x);
-    }
-  end
-
-  def tan(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      return Math.tan(#{x.to_f});
-    }
-  end
-
-  unless defined?(`Math.tanh`)
-    %x{
-      Math.tanh = function(x) {
-        if (x == Infinity) {
-          return 1;
-        }
-        else if (x == -Infinity) {
-          return -1;
-        }
-        else {
-          return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x));
-        }
-      }
-    }
-  end
-
-  def tanh(x)
-    %x{
-      if (!#{Numeric === x}) {
-        #{raise Opal.type_error(x, Float)};
-      }
-
-      return Math.tanh(#{x.to_f});
-    }
-  end
-
-  class << self
-    include Math
-  end
-end
+warn "DEPRECATION: math is now part of the core library, requiring it is deprecated"