opal 0.5.0 → 0.5.2

data/opal/opal.rb

@@ -0,0 +1,121 @@
+require 'core/runtime'
+require 'core/module'
+require 'core/class'
+require 'core/basic_object'
+require 'core/kernel'
+require 'core/nil_class'
+require 'core/boolean'
+require 'core/error'
+require 'core/regexp'
+require 'core/comparable'
+require 'core/enumerable'
+require 'core/enumerator'
+require 'core/array'
+require 'core/hash'
+require 'core/string'
+require 'core/match_data'
+require 'core/encoding'
+require 'core/numeric'
+require 'core/proc'
+require 'core/method'
+require 'core/range'
+require 'core/time'
+require 'core/struct'
+require 'core/io'
+require 'core/main'
+require 'native'
+
+# regexp matches
+$& = $~ = $` = $' = nil
+
+# stub library path
+$: = []
+$" = []
+
+# split lines
+$/ = "\n"
+$, = " "
+
+ARGV = []
+ARGF = Object.new
+ENV  = {}
+
+$VERBOSE = false
+$DEBUG   = false
+$SAFE    = 0
+
+RUBY_PLATFORM       = 'opal'
+RUBY_ENGINE         = 'opal'
+RUBY_VERSION        = '1.9.3'
+RUBY_ENGINE_VERSION = '0.5.2'
+RUBY_RELEASE_DATE   = '2013-11-11'
+
+module Opal
+  def self.coerce_to(object, type, method)
+    return object if type === object
+
+    unless object.respond_to? method
+      raise TypeError, "no implicit conversion of #{object.class} into #{type}"
+    end
+
+    object.__send__ method
+  end
+
+  def self.coerce_to!(object, type, method)
+    coerced = coerce_to(object, type, method)
+
+    unless type === coerced
+      raise TypeError, "can't convert #{object.class} into #{type} (#{object.class}##{method} gives #{coerced.class}"
+    end
+
+    coerced
+  end
+
+  def self.try_convert(object, type, method)
+    return object if type === object
+
+    if object.respond_to? method
+      object.__send__ method
+    end
+  end
+
+  def self.compare(a, b)
+    compare = a <=> b
+
+    if `compare === nil`
+      raise ArgumentError, "comparison of #{a.class.name} with #{b.class.name} failed"
+    end
+
+    compare
+  end
+
+  def self.truthy?(value)
+    if value
+      true
+    else
+      false
+    end
+  end
+
+  def self.falsy?(value)
+    if value
+      false
+    else
+      true
+    end
+  end
+
+  def self.destructure(args)
+    %x{
+      if (args.length == 1) {
+        return args[0];
+      }
+      else if (args._isArray) {
+        return args;
+      }
+      else {
+        return $slice.call(args);
+      }
+    }
+  end
+end

data/spec/corelib/array/select_spec.rb

@@ -0,0 +1,14 @@
+describe "Array#select" do
+  it "passes an array item into a single default-block parameter" do
+    [["ABC", "DEF"]].select do |x|
+      x.should == ["ABC", "DEF"]
+    end
+  end
+
+  it "splits an array item into a list of default block parameters" do
+    [["ABC", "DEF"]].select do |x,y|
+      x.should == "ABC"
+      y.should == "DEF"
+    end
+  end
+end

data/spec/filters/20.rb

@@ -0,0 +1,4 @@
+opal_filter "2.0 behaviour" do
+  fails "Enumerator.new ignores block if arg given"
+  fails "String#end_with? ignores arguments not convertible to string"
+end

data/spec/filters/bugs/enumerable.rb

@@ -1,58 +1,11 @@
 opal_filter "Enumerable" do
-  fails "Enumerable#drop passed a number n as an argument tries to convert n to an Integer using #to_int"
-
-  fails "Enumerable#drop_while passes elements to the block until the first false"
-
-  fails "Enumerable#each_slice raises an Argument Error if there is not a single parameter > 0"
-
-  fails "Enumerable#each_with_index provides each element to the block"
-  fails "Enumerable#each_with_index provides each element to the block and its index"
-  fails "Enumerable#each_with_index binds splat arguments properly"
-  fails "Enumerable#each_with_index passes extra parameters to each"
-
-  fails "Enumerable#entries passes arguments to each"
-
-  fails "Enumerable#first when passed an argument consumes only what is needed"
-  fails "Enumerable#first when passed an argument raises a TypeError if the passed argument is not numeric"
-  fails "Enumerable#first when passed an argument tries to convert the passed argument to an Integer using #to_int"
-  fails "Enumerable#first when passed an argument raises an ArgumentError when count is negative"
+  fails "Enumerable#cycle passed a number n as an argument raises an ArgumentError if more arguments are passed"
 
   fails "Enumerable#grep can use $~ in the block when used with a Regexp"
 
-  fails "Enumerable#group_by returns a hash without default_proc"
-  fails "Enumerable#group_by gathers whole arrays as elements when each yields multiple"
-
-  fails "Enumerable#include? returns true if any element == argument for numbers"
-  fails "Enumerable#include? gathers whole arrays as elements when each yields multiple"
-
   fails "Enumerable#inject returns nil when fails(legacy rubycon)"
   fails "Enumerable#inject without inject arguments(legacy rubycon)"
-  fails "Enumerable#inject can take a symbol argument"
-  fails "Enumerable#inject ignores the block if two arguments"
-  fails "Enumerable#inject can take two argument"
-
-  fails "Enumerable#max raises an ArgumentError for incomparable elements"
-  fails "Enumerable#max gathers whole arrays as elements when each yields multiple"
-
-  fails "Enumerable#member? returns true if any element == argument for numbers"
-  fails "Enumerable#member? gathers whole arrays as elements when each yields multiple"
-
-  fails "Enumerable#min raises an ArgumentError for incomparable elements"
-  fails "Enumerable#min gathers whole arrays as elements when each yields multiple"
 
   fails "Enumerable#reduce returns nil when fails(legacy rubycon)"
   fails "Enumerable#reduce without inject arguments(legacy rubycon)"
-  fails "Enumerable#reduce can take a symbol argument"
-  fails "Enumerable#reduce ignores the block if two arguments"
-  fails "Enumerable#reduce can take two argument"
-
-  fails "Enumerable#select passes through the values yielded by #each_with_index"
-  fails "Enumerable#select returns an enumerator when no block given"
-
-  fails "Enumerable#take when passed an argument consumes only what is needed"
-  fails "Enumerable#take when passed an argument raises a TypeError if the passed argument is not numeric"
-  fails "Enumerable#take when passed an argument tries to convert the passed argument to an Integer using #to_int"
-  fails "Enumerable#take when passed an argument raises an ArgumentError when count is negative"
-
-  fails "Enumerable#to_a passes arguments to each"
 end

data/spec/filters/unsupported/enumerator.rb

@@ -0,0 +1,13 @@
+opal_filter "Enumerator as generator" do
+  fails "Enumerator#next returns the next element of the enumeration"
+  fails "Enumerator#next raises a StopIteration exception at the end of the stream"
+  fails "Enumerator#next cannot be called again until the enumerator is rewound"
+
+  fails "Enumerator#rewind resets the enumerator to its initial state"
+  fails "Enumerator#rewind returns self"
+  fails "Enumerator#rewind has no effect on a new enumerator"
+  fails "Enumerator#rewind has no effect if called multiple, consecutive times"
+  fails "Enumerator#rewind does nothing if the object doesn't have a #rewind method"
+  fails "Enumerator#rewind works with peek to reset the position"
+  fails "Enumerator#rewind calls the enclosed object's rewind method if one exists"
+end

data/spec/opal/compiler/irb_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'native'
 
 describe Opal::Compiler do
   describe "irb parser option" do

data/spec/rubyspecs

@@ -116,6 +116,7 @@ core/nil/xor_spec
 
 core/enumerable/all_spec
 core/enumerable/any_spec
+core/enumerable/cycle_spec
 core/enumerable/collect_spec
 core/enumerable/count_spec
 core/enumerable/detect_spec

data/spec/{corelib → stdlib}/native/alias_native_spec.rb

@@ -1,7 +1,9 @@
-describe "Native::Base.alias_native" do
+require 'native'
+
+describe "Native.alias_native" do
   it "refers to an attribute on @native" do
     Class.new {
-      include Native::Base
+      include Native
 
       alias_native :a, :a
     }.new(`{ a: 2 }`).a.should == 2
@@ -9,7 +11,7 @@ describe "Native::Base.alias_native" do
 
   it "refers to an attribute on @native and calls it if it's a function" do
     Class.new {
-      include Native::Base
+      include Native
 
       alias_native :a, :a
     }.new(`{ a: function() { return 42; } }`).a.should == 42
@@ -17,7 +19,7 @@ describe "Native::Base.alias_native" do
 
   it "defaults old to new" do
     Class.new {
-      include Native::Base
+      include Native
 
       alias_native :a
     }.new(`{ a: 42 }`).a.should == 42

data/spec/{corelib → stdlib}/native/each_spec.rb

@@ -1,4 +1,6 @@
-describe "Native#each" do
+require 'native'
+
+describe "Native::Object#each" do
   it "enumerates on object properties" do
     Native(`{ a: 2, b: 3 }`).each {|name, value|
       ((name == :a && value == 2) || (name == :b && value == 3)).should be_true

data/spec/{corelib → stdlib}/native/element_reference_spec.rb

@@ -1,4 +1,6 @@
-describe "Native#[]" do
+require 'native'
+
+describe "Native::Object#[]" do
   it "should return the same value for bridged classes" do
     Native(`2`).should === 2
     Native(`"lol"`).should === "lol"

data/spec/stdlib/native/ext_spec.rb

@@ -0,0 +1,19 @@
+require 'native'
+
+describe Hash do
+  describe '#initialize' do
+    it "returns a hash with a nil value" do
+      h = Hash.new(`{a: null}`)
+      h[:a].should == nil
+    end
+  end
+
+  describe '#to_n' do
+    it "should return a js object representing hash" do
+      Hash.new({:a => 100, :b => 200}.to_n).should == {:a => 100, :b => 200}
+    end
+  end
+end
+
+describe "Hash#to_n" do
+end

data/spec/{corelib → stdlib}/native/initialize_spec.rb

@@ -1,17 +1,17 @@
 require 'native'
 
-describe "Native::Base#initialize" do
-  it "works when Native::Base is included in a BasicObject" do
+describe "Native#initialize" do
+  it "works when Native is included in a BasicObject" do
     basic_class = Class.new(BasicObject)
     basic_object = basic_class.new
     lambda { basic_object.native? }.should raise_error(NoMethodError)
 
-    basic_class.send :include, Native::Base
+    basic_class.send :include, Native
     lambda { basic_class.new(`{}`) }.should_not raise_error
   end
 
   it "detects a non native object" do
     object = Object.new
-    lambda { Native.new(object) }.should raise_error(ArgumentError)
+    lambda { Native::Object.new(object) }.should raise_error(ArgumentError)
   end
 end

data/spec/{corelib → stdlib}/native/method_missing_spec.rb

@@ -1,4 +1,6 @@
-describe "Native#method_missing" do
+require 'native'
+
+describe "Native::Object#method_missing" do
   it "should return values" do
     Native(`{ a: 23 }`).a.should == 23
     Native(`{ a: { b: 42 } }`).a.b.should == 42
@@ -36,4 +38,14 @@ describe "Native#method_missing" do
   it "should pass the block as function" do
     Native(`{ a: function(func) { return func(); } }`).a { 42 }.should == 42
   end
+
+  it "should unwrap arguments" do
+    x = `{}`
+
+    Native(`{ a: function(a, b) { return a === b } }`).a(Native(x), x).should == true
+  end
+
+  it "should wrap result" do
+    Native(`{ a: function() { return {}; } }`).a.class.should == Native::Object
+  end
 end

data/spec/{corelib → stdlib}/native/new_spec.rb

@@ -1,4 +1,6 @@
-describe "Native.new" do
+require 'native'
+
+describe "Native()" do
   it "should return nil for null or undefined" do
     Native(`null`).should be_nil
     Native(`undefined`).should be_nil

data/stdlib/enumerator.rb

@@ -0,0 +1 @@
+# stub

data/stdlib/json.rb

@@ -78,7 +78,7 @@ module JSON
     options[:object_class] ||= Hash
     options[:array_class]  ||= Array
 
-    `to_opal(js_object, #{options.to_n})`
+    `to_opal(js_object, options.map)`
   end
 
   def self.generate(obj, options = {})

data/stdlib/native.rb

@@ -0,0 +1,483 @@
+module Kernel
+  def native?(value)
+    `value == null || !value._klass`
+  end
+
+  def Native(obj)
+    if `#{obj} == null`
+      nil
+    elsif native?(obj)
+      Native::Object.new(obj)
+    else
+      obj
+    end
+  end
+
+  def Array(object, *args, &block)
+    %x{
+      if (object == null || object === nil) {
+        return [];
+      }
+      else if (#{native?(object)}) {
+        return #{Native::Array.new(object, *args, &block).to_a};
+      }
+      else if (#{object.respond_to? :to_ary}) {
+        return #{object.to_ary};
+      }
+      else if (#{object.respond_to? :to_a}) {
+        return #{object.to_a};
+      }
+      else {
+        return [object];
+      }
+    }
+  end
+end
+
+module Native
+  def self.is_a?(object, klass)
+    %x{
+      try {
+        return #{object} instanceof #{Native.try_convert(klass)};
+      }
+      catch (e) {
+        return false;
+      }
+    }
+  end
+
+  def self.try_convert(value)
+    %x{
+      if (#{native?(value)}) {
+        return #{value};
+      }
+      else if (#{value.respond_to? :to_n}) {
+        return #{value.to_n};
+      }
+      else {
+        return nil;
+      }
+    }
+  end
+
+  def self.convert(value)
+    native = try_convert(value)
+
+    if `#{native} === nil`
+      raise ArgumentError, "the passed value isn't a native"
+    end
+
+    native
+  end
+
+  def self.call(obj, key, *args, &block)
+    %x{
+      var prop = #{obj}[#{key}];
+
+      if (prop == null) {
+        return nil;
+      }
+      else if (prop instanceof Function) {
+        if (block !== nil) {
+          args.push(block);
+        }
+
+        args = #{args.map {|value|
+          native = try_convert(value)
+
+          if nil === native
+            value
+          else
+            native
+          end
+        }};
+
+        return #{Native(`prop.apply(#{obj}, #{args})`)};
+      }
+      else if (#{native?(`prop`)}) {
+        return #{Native(`prop`)};
+      }
+      else {
+        return prop;
+      }
+    }
+  end
+
+  module Helpers
+    def alias_native(new, old = new, options = {})
+      if old.end_with? ?=
+        define_method new do |value|
+          `#@native[#{old[0 .. -2]}] = #{Native.convert(value)}`
+
+          value
+        end
+      else
+        if as = options[:as]
+          define_method new do |*args, &block|
+            if value = Native.call(@native, old, *args, &block)
+              as.new(value.to_n)
+            end
+          end
+        else
+          define_method new do |*args, &block|
+            Native.call(@native, old, *args, &block)
+          end
+        end
+      end
+    end
+  end
+
+  def self.included(klass)
+    klass.extend Helpers
+  end
+
+  def initialize(native)
+    unless Kernel.native?(native)
+      Kernel.raise ArgumentError, "the passed value isn't native"
+    end
+
+    @native = native
+  end
+
+  def to_n
+    @native
+  end
+
+  class Object < BasicObject
+    include Native
+
+    def ==(other)
+      `#@native === #{Native.try_convert(other)}`
+    end
+
+    def has_key?(name)
+      `#@native.hasOwnProperty(#{name})`
+    end
+
+    alias key? has_key?
+    alias include? has_key?
+    alias member? has_key?
+
+    def each(*args)
+      if block_given?
+        %x{
+          for (var key in #@native) {
+            #{yield `key`, `#@native[key]`}
+          }
+        }
+
+        self
+      else
+        method_missing(:each, *args)
+      end
+    end
+
+    def [](key)
+      %x{
+        var prop = #@native[key];
+
+        if (prop instanceof Function) {
+          return prop;
+        }
+        else {
+          return #{::Native.call(@native, key)}
+        }
+      }
+    end
+
+    def []=(key, value)
+      native = Native.try_convert(value)
+
+      if `#{native} === nil`
+        `#@native[key] = #{value}`
+      else
+        `#@native[key] = #{native}`
+      end
+    end
+
+    def method_missing(mid, *args, &block)
+      %x{
+        if (mid.charAt(mid.length - 1) === '=') {
+          return #{self[mid.slice(0, mid.length - 1)] = args[0]};
+        }
+        else {
+          return #{::Native.call(@native, mid, *args, &block)};
+        }
+      }
+    end
+
+    def nil?
+      false
+    end
+
+    def is_a?(klass)
+      klass == Native
+    end
+
+    alias kind_of? is_a?
+
+    def instance_of?(klass)
+      klass == Native
+    end
+
+    def class
+      `self._klass`
+    end
+
+    def to_a(options = {}, &block)
+      Native::Array.new(@native, options, &block).to_a
+    end
+
+    def to_ary(options = {}, &block)
+      Native::Array.new(@native, options, &block)
+    end
+
+    def inspect
+      "#<Native:#{`String(#@native)`}>"
+    end
+  end
+
+  class Array
+    include Native
+    include Enumerable
+
+    def initialize(native, options = {}, &block)
+      super(native)
+
+      @get    = options[:get] || options[:access]
+      @named  = options[:named]
+      @set    = options[:set] || options[:access]
+      @length = options[:length] || :length
+      @block  = block
+
+      if `#{length} == null`
+        raise ArgumentError, "no length found on the array-like object"
+      end
+    end
+
+    def each(&block)
+      return enum_for :each unless block
+
+      index  = 0
+      length = self.length
+
+      while index < length
+        block.call(self[index])
+
+        index += 1
+      end
+
+      self
+    end
+
+    def [](index)
+      result = case index
+        when String, Symbol
+          @named ? `#@native[#@named](#{index})` : `#@native[#{index}]`
+
+        when Integer
+          @get ? `#@native[#@get](#{index})` : `#@native[#{index}]`
+      end
+
+      if result
+        if @block
+          @block.call(result)
+        else
+          Native(result)
+        end
+      end
+    end
+
+    def []=(index, value)
+      if @set
+        `#@native[#@set](#{index}, #{value})`
+      else
+        `#@native[#{index}] = #{value}`
+      end
+    end
+
+    def last(count = nil)
+      if count
+        index  = length - 1
+        result = []
+
+        while index >= 0
+          result << self[index]
+          index  -= 1
+        end
+
+        result
+      else
+        self[length - 1]
+      end
+    end
+
+    def length
+      `#@native[#@length]`
+    end
+
+    def to_ary
+      self
+    end
+
+    def inspect
+      to_a.inspect
+    end
+  end
+end
+
+class Numeric
+  def to_n
+    `self.valueOf()`
+  end
+end
+
+class Proc
+  def to_n
+    self
+  end
+end
+
+class String
+  def to_n
+    `self.valueOf()`
+  end
+end
+
+class Regexp
+  def to_n
+    `self.valueOf()`
+  end
+end
+
+class MatchData
+  def to_n
+    @matches
+  end
+end
+
+class Struct
+  def initialize(*args)
+    if args.length == 1 && native?(args[0])
+      object = args[0]
+
+      members.each {|name|
+        instance_variable_set "@#{name}", Native(`#{object}[#{name}]`)
+      }
+    else
+      members.each_with_index {|name, index|
+        instance_variable_set "@#{name}", args[index]
+      }
+    end
+  end
+
+  def to_n
+    result = `{}`
+
+    each_pair {|name, value|
+      `#{result}[#{name}] = #{value.to_n}`
+    }
+
+    result
+  end
+end
+
+class Array
+  def to_n
+    %x{
+      var result = [];
+
+      for (var i = 0, length = self.length; i < length; i++) {
+        var obj = self[i];
+
+        if (#{`obj`.respond_to? :to_n}) {
+          result.push(#{`obj`.to_n});
+        }
+        else {
+          result.push(obj);
+        }
+      }
+
+      return result;
+    }
+  end
+end
+
+class Boolean
+  def to_n
+    `self.valueOf()`
+  end
+end
+
+class Time
+  def to_n
+    self
+  end
+end
+
+class NilClass
+  def to_n
+    `null`
+  end
+end
+
+class Hash
+  def initialize(defaults = undefined, &block)
+    %x{
+      if (defaults != null) {
+        if (defaults.constructor === Object) {
+          var map  = self.map,
+              keys = self.keys;
+
+          for (var key in defaults) {
+            var value = defaults[key];
+
+            if (value && value.constructor === Object) {
+              map[key] = #{Hash.new(`value`)};
+            }
+            else {
+              map[key] = #{Native(`defaults[key]`)};
+            }
+
+            keys.push(key);
+          }
+        }
+        else {
+          self.none = defaults;
+        }
+      }
+      else if (block !== nil) {
+        self.proc = block;
+      }
+
+      return self;
+    }
+  end
+
+  def to_n
+    %x{
+      var result = {},
+          keys   = self.keys,
+          map    = self.map,
+          bucket,
+          value;
+
+      for (var i = 0, length = keys.length; i < length; i++) {
+        var key = keys[i],
+            obj = map[key];
+
+        if (#{`obj`.respond_to? :to_n}) {
+          result[key] = #{`obj`.to_n};
+        }
+        else {
+          result[key] = obj;
+        }
+      }
+
+      return result;
+    }
+  end
+end
+
+# native global
+$$ = $global = Native(`Opal.global`)