opal 0.5.2 → 0.5.4

data/stdlib/buffer.rb

@@ -2,7 +2,7 @@ require 'buffer/array'
 require 'buffer/view'
 
 class Buffer
-  include Native::Base
+  include Native
 
   def self.supported?
     not $$[:ArrayBuffer].nil?

data/stdlib/buffer/view.rb

@@ -1,7 +1,7 @@
 class Buffer
 
 class View
-  include Native::Base
+  include Native
 
   def self.supported?
     not $$[:DataView].nil?

data/stdlib/native.rb

@@ -1,39 +1,3 @@
-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{
@@ -61,13 +25,17 @@ module Native
   end
 
   def self.convert(value)
-    native = try_convert(value)
-
-    if `#{native} === nil`
-      raise ArgumentError, "the passed value isn't a native"
-    end
-
-    native
+    %x{
+      if (#{native?(value)}) {
+        return #{value};
+      }
+      else if (#{value.respond_to? :to_n}) {
+        return #{value.to_n};
+      }
+      else {
+        #{raise ArgumentError, "the passed value isn't a native"};
+      }
+    }
   end
 
   def self.call(obj, key, *args, &block)
@@ -142,187 +110,224 @@ module Native
   def to_n
     @native
   end
+end
 
-  class Object < BasicObject
-    include Native
+module Kernel
+  def native?(value)
+    `value == null || !value._klass`
+  end
 
-    def ==(other)
-      `#@native === #{Native.try_convert(other)}`
+  def Native(obj)
+    if `#{obj} == null`
+      nil
+    elsif native?(obj)
+      Native::Object.new(obj)
+    else
+      obj
     end
+  end
 
-    def has_key?(name)
-      `#@native.hasOwnProperty(#{name})`
-    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
 
-    alias key? has_key?
-    alias include? has_key?
-    alias member? has_key?
+class Native::Object < BasicObject
+  include Native
 
-    def each(*args)
-      if block_given?
-        %x{
-          for (var key in #@native) {
-            #{yield `key`, `#@native[key]`}
-          }
-        }
+  def ==(other)
+    `#@native === #{Native.try_convert(other)}`
+  end
 
-        self
-      else
-        method_missing(:each, *args)
-      end
-    end
+  def has_key?(name)
+    `#@native.hasOwnProperty(#{name})`
+  end
 
-    def [](key)
-      %x{
-        var prop = #@native[key];
+  alias key? has_key?
+  alias include? has_key?
+  alias member? has_key?
 
-        if (prop instanceof Function) {
-          return prop;
-        }
-        else {
-          return #{::Native.call(@native, key)}
+  def each(*args)
+    if block_given?
+      %x{
+        for (var key in #@native) {
+          #{yield `key`, `#@native[key]`}
         }
       }
-    end
-
-    def []=(key, value)
-      native = Native.try_convert(value)
 
-      if `#{native} === nil`
-        `#@native[key] = #{value}`
-      else
-        `#@native[key] = #{native}`
-      end
+      self
+    else
+      method_missing(:each, *args)
     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)};
-        }
+  def [](key)
+    %x{
+      var prop = #@native[key];
+
+      if (prop instanceof Function) {
+        return prop;
       }
-    end
+      else {
+        return #{::Native.call(@native, key)}
+      }
+    }
+  end
 
-    def nil?
-      false
-    end
+  def []=(key, value)
+    native = Native.try_convert(value)
 
-    def is_a?(klass)
-      klass == Native
+    if `#{native} === nil`
+      `#@native[key] = #{value}`
+    else
+      `#@native[key] = #{native}`
     end
+  end
 
-    alias kind_of? is_a?
+  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 instance_of?(klass)
-      klass == Native
-    end
+  def nil?
+    false
+  end
 
-    def class
-      `self._klass`
-    end
+  def is_a?(klass)
+    klass == Native
+  end
 
-    def to_a(options = {}, &block)
-      Native::Array.new(@native, options, &block).to_a
-    end
+  alias kind_of? is_a?
 
-    def to_ary(options = {}, &block)
-      Native::Array.new(@native, options, &block)
-    end
+  def instance_of?(klass)
+    klass == Native
+  end
 
-    def inspect
-      "#<Native:#{`String(#@native)`}>"
-    end
+  def class
+    `self._klass`
+  end
+
+  def to_a(options = {}, &block)
+    Native::Array.new(@native, options, &block).to_a
   end
 
-  class Array
-    include Native
-    include Enumerable
+  def to_ary(options = {}, &block)
+    Native::Array.new(@native, options, &block)
+  end
 
-    def initialize(native, options = {}, &block)
-      super(native)
+  def inspect
+    "#<Native:#{`String(#@native)`}>"
+  end
+end
 
-      @get    = options[:get] || options[:access]
-      @named  = options[:named]
-      @set    = options[:set] || options[:access]
-      @length = options[:length] || :length
-      @block  = block
+class Native::Array
+  include Native
+  include Enumerable
 
-      if `#{length} == null`
-        raise ArgumentError, "no length found on the array-like object"
-      end
-    end
+  def initialize(native, options = {}, &block)
+    super(native)
 
-    def each(&block)
-      return enum_for :each unless block
+    @get    = options[:get] || options[:access]
+    @named  = options[:named]
+    @set    = options[:set] || options[:access]
+    @length = options[:length] || :length
+    @block  = block
 
-      index  = 0
-      length = self.length
+    if `#{length} == null`
+      raise ArgumentError, "no length found on the array-like object"
+    end
+  end
 
-      while index < length
-        block.call(self[index])
+  def each(&block)
+    return enum_for :each unless block
 
-        index += 1
-      end
+    %x{
+      for (var i = 0, length = #{length}; i < length; i++) {
+        var value = $opal.$yield1(block, #{self[`i`]});
 
-      self
-    end
+        if (value === $breaker) {
+          return $breaker.$v;
+        }
+      }
+    }
 
-    def [](index)
-      result = case index
-        when String, Symbol
-          @named ? `#@native[#@named](#{index})` : `#@native[#{index}]`
+    self
+  end
 
-        when Integer
-          @get ? `#@native[#@get](#{index})` : `#@native[#{index}]`
-      end
+  def [](index)
+    result = case index
+      when String, Symbol
+        @named ? `#@native[#@named](#{index})` : `#@native[#{index}]`
 
-      if result
-        if @block
-          @block.call(result)
-        else
-          Native(result)
-        end
-      end
+      when Integer
+        @get ? `#@native[#@get](#{index})` : `#@native[#{index}]`
     end
 
-    def []=(index, value)
-      if @set
-        `#@native[#@set](#{index}, #{value})`
+    if result
+      if @block
+        @block.call(result)
       else
-        `#@native[#{index}] = #{value}`
+        Native(result)
       end
     end
+  end
 
-    def last(count = nil)
-      if count
-        index  = length - 1
-        result = []
+  def []=(index, value)
+    if @set
+      `#@native[#@set](#{index}, #{Native.convert(value)})`
+    else
+      `#@native[#{index}] = #{Native.convert(value)}`
+    end
+  end
 
-        while index >= 0
-          result << self[index]
-          index  -= 1
-        end
+  def last(count = nil)
+    if count
+      index  = length - 1
+      result = []
 
-        result
-      else
-        self[length - 1]
+      while index >= 0
+        result << self[index]
+        index  -= 1
       end
-    end
 
-    def length
-      `#@native[#@length]`
+      result
+    else
+      self[length - 1]
     end
+  end
 
-    def to_ary
-      self
-    end
+  def length
+    `#@native[#@length]`
+  end
 
-    def inspect
-      to_a.inspect
-    end
+  def to_ary
+    self
+  end
+
+  def inspect
+    to_a.inspect
   end
 end
 
@@ -479,5 +484,19 @@ class Hash
   end
 end
 
+class Module
+  def native_module
+    `Opal.global[#{self.name}] = #{self}`
+  end
+end
+
+class Class
+  def native_alias(jsid, mid)
+    `#{self}._proto[#{jsid}] = #{self}._proto['$' + #{mid}]`
+  end
+
+  alias native_class native_module
+end
+
 # native global
 $$ = $global = Native(`Opal.global`)