opal 0.4.4 → 0.5.0

data/spec/{opal → stdlib}/erb/erb_spec.rb

@@ -6,9 +6,9 @@ require File.expand_path('../inline_block', __FILE__)
 
 describe "ERB files" do
   before :each do
-    @simple = Template['opal/erb/simple']
-    @quoted = Template['opal/erb/quoted']
-    @inline_block = Template['opal/erb/inline_block']
+    @simple = Template['stdlib/erb/simple']
+    @quoted = Template['stdlib/erb/quoted']
+    @inline_block = Template['stdlib/erb/inline_block']
   end
 
   it "should be defined by their filename on Template namespace" do

data/spec/stdlib/json/ext_spec.rb

@@ -0,0 +1,48 @@
+require 'json'
+
+describe "Hash#to_json" do
+  it "returns a string of all key and value pairs" do
+    {}.to_json.should == "{}"
+    {"a" => 1, "b" => 2}.to_json.should == '{"a":1, "b":2}'
+
+    hash = {"a" => 1, "b" => false, "c" => nil, "d" => true}
+    JSON.parse(hash.to_json).should == hash
+  end
+end
+
+describe "Array#to_json" do
+  it "returns a string of all array elements converted to json" do
+    [].to_json.should == "[]"
+    [1, 2, 3].to_json.should == "[1, 2, 3]"
+    [true, nil, false, "3", 42].to_json.should == '[true, null, false, "3", 42]'
+  end
+end
+
+describe "Boolean#to_json" do
+  it "returns 'true' when true" do
+    true.to_json.should == "true"
+  end
+
+  it "returns 'false' when false" do
+    false.to_json.should == "false"
+  end
+end
+
+describe "Kernel#to_json" do
+  it "returns an escaped #to_s of the receiver" do
+    self.to_json.should be_kind_of(String)
+  end
+end
+
+describe "NilClass#to_json" do
+  it "returns 'null'" do
+    nil.to_json.should == "null"
+  end
+end
+
+describe "String#to_json" do
+  it "returns an escaped string" do
+    "foo".to_json.should == "\"foo\""
+    "bar\nbaz".to_json.should == "\"bar\\nbaz\""
+  end
+end

data/spec/stdlib/template/paths_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'template'
+
+describe Template do
+  describe ".paths" do
+    it "should be an array of registered templates" do
+      Template.paths.should be_kind_of(Array)
+    end
+  end
+end

data/stdlib/delegate.rb

@@ -0,0 +1,29 @@
+class Delegator < BasicObject
+  def initialize(obj)
+    __setobj__(obj)
+  end
+
+  def method_missing(m, *args, &block)
+    target = self.__getobj__
+
+    if target.respond_to?(m)
+      target.__send__(m, *args, &block)
+    else
+      super(m, *args, &block)
+    end
+  end
+end
+
+class SimpleDelegator < Delegator
+  def __getobj__
+    @delegate_sd_obj
+  end
+
+  def __setobj__(obj)
+    @delegate_sd_obj = obj
+  end
+end
+
+def DelegateClass(superklass)
+  SimpleDelegator
+end

data/stdlib/dir.rb

@@ -0,0 +1,5 @@
+class Dir
+  def self.getwd
+    '.'
+  end
+end

data/stdlib/file.rb

@@ -0,0 +1,7 @@
+class File
+  SEPARATOR = '/'
+
+  def self.expand_path(path, *)
+    path
+  end
+end

data/stdlib/json.rb

@@ -1,17 +1,9 @@
-`var json_parse = JSON.parse, __hasOwn = Object.prototype.hasOwnProperty`
-
 module JSON
-  def self.parse(source)
-    `return to_opal(json_parse(source));`
-  end
-
-  # Raw js object => opal object
-  def self.from_object(js_object)
-    `return to_opal(js_object)`
-  end
-
   %x{
-    function to_opal(value) {
+    var $parse  = JSON.parse,
+        $hasOwn = Opal.hasOwnProperty;
+
+    function to_opal(value, options) {
       switch (typeof value) {
         case 'string':
           return value;
@@ -29,37 +21,90 @@ module JSON
           if (!value) return nil;
 
           if (value._isArray) {
-            var arr = [];
+            var arr = #{`options.array_class`.new};
 
             for (var i = 0, ii = value.length; i < ii; i++) {
-              arr.push(to_opal(value[i]));
+              #{`arr`.push(`to_opal(value[i], options)`)};
             }
 
             return arr;
           }
           else {
-            var hash = #{ {} }, v, map = hash.map, keys = hash.keys;
+            var hash = #{`options.object_class`.new};
 
             for (var k in value) {
-              if (__hasOwn.call(value, k)) {
-                v = to_opal(value[k]);
-                keys.push(k);
-                map[k] = v;
+              if ($hasOwn.call(value, k)) {
+                #{`hash`[`k`] = `to_opal(value[k], options)`};
               }
             }
-          }
 
-          return hash;
+            var klass;
+            if ((klass = #{`hash`[JSON.create_id]}) != nil) {
+              klass = Opal.cget(klass);
+              return #{`klass`.json_create(`hash`)};
+            }
+            else {
+              return hash;
+            }
+          }
       }
     };
   }
+
+  class << self
+    attr_accessor :create_id
+  end
+
+  self.create_id = :json_class
+
+  def self.[](value, options = {})
+    if String === value
+      parse(value, options)
+    else
+      generate(value, options)
+    end
+  end
+
+  def self.parse(source, options = {})
+    from_object(`$parse(source)`, options)
+  end
+
+  def self.parse!(source, options = {})
+    parse(source, options)
+  end
+
+  # Raw js object => opal object
+  def self.from_object(js_object, options = {})
+    options[:object_class] ||= Hash
+    options[:array_class]  ||= Array
+
+    `to_opal(js_object, #{options.to_n})`
+  end
+
+  def self.generate(obj, options = {})
+    obj.to_json(options)
+  end
+
+  def self.dump(obj, io = nil, limit = nil)
+    string = generate(obj)
+
+    if io
+      io = io.to_io if io.responds_to? :to_io
+      io.write string
+
+      io
+    else
+      string
+    end
+  end
 end
 
-module Kernel
+class Object
   def to_json
     to_s.to_json
   end
 
+  # FIXME: remove this
   def as_json
     nil
   end
@@ -71,7 +116,7 @@ class Array
       var result = [];
 
       for (var i = 0, length = #{self}.length; i < length; i++) {
-        result.push(#{ `#{self}[i]`.to_json });
+        result.push(#{`self[i]`.to_json});
       }
 
       return '[' + result.join(', ') + ']';
@@ -81,23 +126,24 @@ class Array
 end
 
 class Boolean
+  # FIXME: remove this
   def as_json
     self
   end
 
   def to_json
-    `(#{self} == true) ? 'true' : 'false'`
+    `(self == true) ? 'true' : 'false'`
   end
 end
 
 class Hash
   def to_json
     %x{
-      var inspect = [], keys = #{self}.keys, map = #{self}.map;
+      var inspect = [], keys = self.keys, map = self.map;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i];
-        inspect.push(#{`key`.to_json} + ': ' + #{`map[key]`.to_json});
+        inspect.push(#{`key`.to_s.to_json} + ':' + #{`map[key]`.to_json});
       }
 
       return '{' + inspect.join(', ') + '}';
@@ -106,6 +152,7 @@ class Hash
 end
 
 class NilClass
+  # FIXME: remove this
   def as_json
     self
   end
@@ -116,19 +163,27 @@ class NilClass
 end
 
 class Numeric
+  # FIXME: remove this
   def as_json
     self
   end
 
   def to_json
-    `#{self}.toString()`
+    `self.toString()`
   end
 end
 
 class String
+  # FIXME: remove this
   def as_json
     self
   end
 
   alias to_json inspect
 end
+
+class Time
+  def to_json
+    strftime("%FT%T%z").to_json
+  end
+end

data/stdlib/opal-parser.rb

@@ -0,0 +1,46 @@
+require 'opal/compiler'
+require 'opal/builder'
+require 'opal/erb'
+require 'opal/version'
+
+module Opal
+  def self.compile(source, options = {})
+    Compiler.new.compile(source, options)
+  end
+end
+
+module Kernel
+  def eval(str)
+    code = Opal.compile str
+    `eval(#{code})`
+  end
+end
+
+%x{
+  Opal.compile = function(str) {
+    return Opal.Opal.$compile(str);
+  };
+
+  Opal.eval = function(str) {
+    return eval(Opal.compile(str));
+  };
+
+  function run_ruby_scripts() {
+    var tags = document.getElementsByTagName('script');
+
+    for (var i = 0, len = tags.length; i < len; i++) {
+      if (tags[i].type === "text/ruby") {
+        Opal.eval(tags[i].innerHTML);
+      }
+    }
+  }
+
+  if (typeof(document) !== 'undefined') {
+    if (window.addEventListener) {
+      window.addEventListener('DOMContentLoaded', run_ruby_scripts, false);
+    }
+    else {
+      window.attachEvent('onload', run_ruby_scripts);
+    }
+  }
+}

data/stdlib/opal-source-maps.js.erb

@@ -1,2 +1,2 @@
 <% require_asset 'source_map' %>
-<%= Opal::SprocketsParser.parse File.read(File.join Opal.core_dir, '..', 'lib', "opal/source_map.rb") %>
+<%= Opal.compile File.read(File.join Opal.core_dir, '..', 'lib', "opal/source_map.rb") %>

data/stdlib/pathname.rb

@@ -0,0 +1,31 @@
+class Pathname
+  def initialize path
+    raise ArgumentError if path == "\0"
+    @path = path
+  end
+
+  attr_reader :path
+
+  def == other
+    other.path == @path
+  end
+
+  def absolute?
+    @path.start_with? '/'
+  end
+
+  def relative?
+    !absolute?
+  end
+
+  def to_path
+    @path
+  end
+  alias :to_str :to_path
+  alias :to_s :to_path
+end
+
+module Kernel
+  def Pathname(path)
+  end
+end

data/stdlib/securerandom.rb

@@ -0,0 +1,12 @@
+module SecureRandom
+  def self.uuid
+    "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".gsub /[xy]/ do |ch,|
+      %x{
+        var r = Math.random() * 16 | 0,
+            v = ch == "x" ? r : (r & 3 | 8);
+
+        return v.toString(16);
+      }
+    end
+  end
+end

data/stdlib/set.rb

@@ -0,0 +1,89 @@
+class Set
+  include Enumerable
+
+  def self.[](*ary)
+    new(ary)
+  end
+
+  def initialize(enum = nil, &block)
+    @hash = Hash.new
+
+    return if enum.nil?
+
+    if block
+      do_with_enum(enum) { |o| add(block[o]) }
+    else
+      merge(enum)
+    end
+  end
+
+  def ==(other)
+    if self.equal?(other)
+      true
+    elsif other.instance_of?(self.class)
+      @hash == other.instance_variable_get(:@hash)
+    elsif other.is_a?(Set) && self.size == other.size
+      other.all? { |o| @hash.include?(o) }
+    else
+      false
+    end
+  end
+
+  def add(o)
+    @hash[o] = true
+    self
+  end
+  alias << add
+
+  def add?(o)
+    if include?(o)
+      nil
+    else
+      add(o)
+    end
+  end
+
+  def each(&block)
+    return enum_for :each unless block_given?
+    @hash.each_key(&block)
+    self
+  end
+
+  def empty?
+    @hash.empty?
+  end
+
+  def clear
+    @hash.clear
+    self
+  end
+
+  def include?(o)
+    @hash.include?(o)
+  end
+  alias member? include?
+
+  def merge(enum)
+    do_with_enum(enum) { |o| add o }
+    self
+  end
+
+  def do_with_enum(enum, &block)
+    enum.each(&block)
+  end
+
+  def size
+    @hash.size
+  end
+  alias length size
+
+  def to_a
+    @hash.keys
+  end
+end
+
+module Enumerable
+  def to_set(klass = Set, *args, &block)
+    klass.new(self, *args, &block)
+  end
+end