opal 0.8.1 → 0.9.0.beta1

data/stdlib/native.rb

@@ -1,3 +1,17 @@
+# Public: Provides a complete set of tools to wrap native JavaScript
+# into nice Ruby objects.
+#
+# Examples
+#
+#   $$.document.querySelector('p').classList.add('blue')
+#   # => adds "blue" class to <p>
+#
+#   $$.location.href = 'https://google.com'
+#   # => changes page location
+#
+#   do_later = $$[:setTimeout] # Accessing the "setTimeout" property
+#   do_later.call(->{ puts :hello}, 500)
+#
 module Native
   def self.is_a?(object, klass)
     %x{
@@ -64,8 +78,64 @@ module Native
     }
   end
 
+  def self.proc(&block)
+    raise LocalJumpError, "no block given" unless block
+
+    Kernel.proc {|*args|
+      args.map! { |arg| Native(arg) }
+      instance = Native(`this`)
+
+      %x{
+        // if global is current scope, run the block in the scope it was defined
+        if (this === Opal.global) {
+          return block.apply(self, #{args});
+        }
+
+        var self_ = block.$$s;
+        block.$$s = null;
+
+        try {
+          return block.apply(#{instance}, #{args});
+        }
+        finally {
+          block.$$s = self_;
+        }
+      }
+    }
+  end
+
   module Helpers
-    def alias_native(new, old = new, options = {})
+    # Public: Exposes a native JavaScript method to Ruby
+    #
+    #
+    # new - The name of the newly created method.
+    # old - The name of the native JavaScript method to be exposed.
+    #       If the name ends with "=" (e.g. `foo=`) it will be interpreted as
+    #       a property setter. (default: the value of "new")
+    # as  - If provided the values returned by the original method will be
+    #       returned as instances of the passed class. The class passed to "as"
+    #       is expected to accept a native JavaScript value.
+    #
+    # Examples
+    #
+    #   class Element
+    #     include Native::Helpers
+    #
+    #     alias_native :add_class, :addClass
+    #     alias_native :show
+    #     alias_native :hide
+    #
+    #     def initialize(selector)
+    #       @native = `$(#{selector})`
+    #     end
+    #   end
+    #
+    #   titles = Element.new('h1')
+    #   titles.add_class :foo
+    #   titles.hide
+    #   titles.show
+    #
+    def alias_native(new, old = new, as: nil)
       if old.end_with? ?=
         define_method new do |value|
           `#@native[#{old[0 .. -2]}] = #{Native.convert(value)}`
@@ -73,7 +143,7 @@ module Native
           value
         end
       else
-        if as = options[:as]
+        if as
           define_method new do |*args, &block|
             if value = Native.call(@native, old, *args, &block)
               as.new(value.to_n)
@@ -121,6 +191,7 @@ module Native
     @native = native
   end
 
+  # Public: Returns the internal native JavaScript value
   def to_n
     @native
   end
@@ -131,6 +202,12 @@ module Kernel
     `value == null || !value.$$class`
   end
 
+  # Public: Wraps a native JavaScript with Native::Object.new
+  #
+  # Returns:
+  # 1. The wrapped object if it is native
+  # 2. nil for `null` and `undefined`
+  # 3. The object itself if it's not native
   def Native(obj)
     if `#{obj} == null`
       nil
@@ -143,6 +220,7 @@ module Kernel
 
   alias_method :_Array, :Array
 
+  # Public: Wraps array-like JavaScript objects in Native::Array
   def Array(object, *args, &block)
     if native?(object)
       return Native::Array.new(object, *args, &block).to_a
@@ -205,7 +283,7 @@ class Native::Object < BasicObject
 
   def merge!(other)
     %x{
-      var other = #{Native.convert(other)};
+      other = #{Native.convert(other)};
 
       for (var prop in other) {
         #@native[prop] = other[prop];
@@ -219,7 +297,7 @@ class Native::Object < BasicObject
     Kernel.instance_method(:respond_to?).bind(self).call(name, include_all)
   end
 
-  def respond_to_missing?(name)
+  def respond_to_missing?(name, include_all = false)
     `Opal.hasOwnProperty.call(#@native, #{name})`
   end
 
@@ -349,50 +427,43 @@ class Native::Array
 end
 
 class Numeric
+  # Public: Returns the internal JavaScript value (with `valueOf`).
   def to_n
     `self.valueOf()`
   end
 end
 
 class Proc
+  # Public: Returns itself (an instance of `Function`)
   def to_n
     self
   end
 end
 
 class String
+  # Public: Returns the internal JavaScript value (with `valueOf`).
   def to_n
     `self.valueOf()`
   end
 end
 
 class Regexp
+  # Public: Returns the internal JavaScript value (with `valueOf`).
   def to_n
     `self.valueOf()`
   end
 end
 
 class MatchData
+  # Public: Returns the array of matches
   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
-
+  # Public: Returns a JavaScript object with the members as keys and their
+  # values as values.
   def to_n
     result = `{}`
 
@@ -405,6 +476,7 @@ class Struct
 end
 
 class Array
+  # Public: Retuns a copy of itself trying to call #to_n on each member.
   def to_n
     %x{
       var result = [];
@@ -426,87 +498,83 @@ class Array
 end
 
 class Boolean
+  # Public: Returns the internal JavaScript value (with `valueOf`).
   def to_n
     `self.valueOf()`
   end
 end
 
 class Time
+  # Public: Returns itself (an instance of `Date`).
   def to_n
     self
   end
 end
 
 class NilClass
+  # Public: Returns the corresponding JavaScript value (`null`).
   def to_n
     `null`
   end
 end
 
 class Hash
+  alias_method :_initialize, :initialize
+
   def initialize(defaults = undefined, &block)
     %x{
-      if (defaults != null) {
-        if (defaults.constructor === Object) {
-          var _map = self.map,
-              smap = self.smap,
-              keys = self.keys,
-              map, khash, value;
-
-          for (var key in defaults) {
-            value = defaults[key];
-
-            if (key.$$is_string) {
-              map = smap;
-              khash = key;
-            } else {
-              map = _map;
-              khash = key.$hash();
-            }
-
-            if (value && value.constructor === Object) {
-              map[khash] = #{Hash.new(`value`)};
-            }
-            else {
-              map[khash] = #{Native(`value`)};
-            }
-
-            keys.push(key);
+      if (defaults !== undefined && defaults.constructor === Object) {
+        var smap = self.smap,
+            keys = self.keys,
+            key, value;
+
+        for (key in defaults) {
+          value = defaults[key];
+
+          if (value && value.constructor === Object) {
+            smap[key] = #{Hash.new(`value`)};
+          } else if (value && value.$$is_array) {
+            value = value.map(function(item) {
+              if (item && item.constructor === Object) {
+                return #{Hash.new(`item`)};
+              }
+
+              return item;
+            });
+            smap[key] = value
+          } else {
+            smap[key] = #{Native(`value`)};
           }
+
+          keys.push(key);
         }
-        else {
-          self.none = defaults;
-        }
-      }
-      else if (block !== nil) {
-        self.proc = block;
+
+        return self;
       }
 
-      return self;
+      return #{_initialize(defaults, &block)};
     }
   end
 
+  # Public: Returns a JavaScript object with the same keys but calling #to_n on
+  # all values.
   def to_n
     %x{
       var result = {},
-          keys   = self.keys,
-          _map   = self.map,
-          smap   = self.smap,
-          map, khash, value, key;
+          keys = self.keys,
+          smap = self.smap,
+          key, value;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        key   = keys[i];
+        key = keys[i];
 
         if (key.$$is_string) {
-          map = smap;
-          khash = key;
+          value = smap[key];
         } else {
-          map = _map;
-          khash = key.$hash();
+          key = key.key;
+          value = key.value;
         }
 
-        value = map[khash];
-
         if (#{`value`.respond_to? :to_n}) {
           result[key] = #{`value`.to_n};
         }
@@ -521,6 +589,8 @@ class Hash
 end
 
 class Module
+  # Public: Exposes the current module as a property of
+  # the global object (e.g. `window`).
   def native_module
     `Opal.global[#{self.name}] = #{self}`
   end
@@ -543,5 +613,5 @@ class Class
   end
 end
 
-# native global
+# Public: Exposes the global value (would be `window` inside a browser)
 $$ = $global = Native(`Opal.global`)

data/stdlib/nodejs/file.rb

@@ -11,6 +11,11 @@ class File < IO
     `__fs__.readFileSync(#{path}).toString()`
   end
 
+  def self.write path, data
+    `__fs__.writeFileSync(#{path}, #{data})`
+    data.size
+  end
+
   def self.exist? path
     `__fs__.existsSync(#{path})`
   end

data/stdlib/nodejs/fileutils.rb

@@ -2,9 +2,11 @@ module FileUtils
   extend self
   `var __fs__ = #{File}.__fs__`
 
-  def mkdir_p path
-    return true if File.directory? path
-    `__fs__.mkdirSync(#{path})`
+  def chmod(mode, file_list)
+    raise NotImplementedError, 'symbolic mode is not supported, use numeric mode' if String === mode
+    Array(file_list).each do |file|
+      `__fs__.chmodSync(mode, file)`
+    end
   end
 
   def cp source, target
@@ -16,11 +18,16 @@ module FileUtils
     `__fs__.unlinkSync(path)`
   end
 
-  def mv source, target
-    target = File.join(target, File.basename(source)) if File.directory? target
-    `__fs__.renameSync(source, target)`
+  def mkdir_p path
+    return true if File.directory? path
+    `__fs__.mkdirSync(#{path})`
   end
 
   alias mkpath mkdir_p
   alias makedirs mkdir_p
+
+  def mv source, target
+    target = File.join(target, File.basename(source)) if File.directory? target
+    `__fs__.renameSync(source, target)`
+  end
 end

data/stdlib/nodejs/node_modules/js-yaml/node_modules/argparse/README.md

@@ -3,7 +3,7 @@ argparse
 
 [![Build Status](https://secure.travis-ci.org/nodeca/argparse.png?branch=master)](http://travis-ci.org/nodeca/argparse)
 
-CLI arguments parser for node.js. Javascript port of python's
+CLI arguments parser for node.js. JavaScript port of python's
 [argparse](http://docs.python.org/dev/library/argparse.html) module
 (original version 3.2). That's a full port, except some very rare options,
 recorded in issue tracker.

data/stdlib/opal-parser.rb

@@ -1,7 +1,6 @@
 require 'opal/compiler'
 require 'opal/erb'
 require 'opal/version'
-require 'encoding'
 
 module Kernel
   def eval(str)
@@ -27,7 +26,7 @@ end
     return Opal.Opal.$compile(str, options);
   };
 
-  Opal.eval = function(str, options) {
+  Opal['eval'] = function(str, options) {
    return eval(Opal.compile(str, options));
   };
 

data/stdlib/ostruct.rb

@@ -3,7 +3,7 @@ class OpenStruct
     @table = {}
 
     hash.each_pair {|key, value|
-      @table[key.to_sym] = value
+      @table[new_ostruct_member(key)] = value
     } if hash
   end
 
@@ -12,12 +12,18 @@ class OpenStruct
   end
 
   def []=(name, value)
-    @table[name.to_sym] = value
+    @table[new_ostruct_member(name)] = value
   end
 
   def method_missing(name, *args)
+    if args.length > 2
+      raise NoMethodError.new "undefined method `#{name}' for #<OpenStruct>"
+    end
     if name.end_with? '='
-      @table[name[0 .. -2].to_sym] = args[0]
+      if args.length != 1
+        raise ArgumentError.new "wrong number of arguments (0 for 1)"
+      end
+      @table[new_ostruct_member(name[0 .. -2])] = args[0]
     else
       @table[name.to_sym]
     end
@@ -60,10 +66,63 @@ class OpenStruct
   def hash
     @table.hash
   end
+  
+  attr_reader :table
+  
+  def delete_field(name)
+    sym = name.to_sym
+    begin
+      singleton_class.__send__(:remove_method, sym, "#{sym}=")
+    rescue NameError
+    end
+    @table.delete sym
+  end
+  
+  def new_ostruct_member(name)
+    name = name.to_sym
+    unless respond_to?(name)
+      define_singleton_method(name) { @table[name] }
+      define_singleton_method("#{name}=") { |x| @table[name] = x }
+    end
+    name
+  end
 
+  `var ostruct_ids;`
+  
   def inspect
-    "#<#{self.class}: #{each_pair.map {|name, value|
-      "#{name}=#{self[name].inspect}"
-    }.join(" ")}>"
+    %x{
+      var top = (ostruct_ids === undefined),
+          ostruct_id = #{self.__id__};
+    }
+    begin
+      result = "#<#{self.class}"
+      %x{
+        if (top) {
+          ostruct_ids = {};
+        }
+        if (ostruct_ids.hasOwnProperty(ostruct_id)) {
+          return result + ' ...>';
+        }
+        ostruct_ids[ostruct_id] = true;
+      }
+
+      result += ' ' if @table.any?
+
+      result += each_pair.map {|name, value|
+        "#{name}=#{value.inspect}"
+      }.join ", "
+
+      result += ">"
+
+      result    
+    ensure
+      %x{
+        if (top) {
+          ostruct_ids = undefined;
+        }
+      }
+    end
   end
+  
+  alias to_s inspect
 end