opal 0.3.42 → 0.3.43

data/opal/opal.rb

@@ -1,21 +1,23 @@
-#= require opal/runtime
-#= require opal/class
-#= require opal/basic_object
-#= require opal/kernel
-#= require opal/nil_class
-#= require opal/boolean
-#= require opal/error
-#= require opal/regexp
-#= require opal/comparable
-#= require opal/enumerable
-#= require opal/array
-#= require opal/hash
-#= require opal/string
-#= require opal/numeric
-#= require opal/proc
-#= require opal/range
-#= require opal/time
-#= require opal/json
+require 'opal/runtime'
+require 'opal/class'
+require 'opal/basic_object'
+require 'opal/kernel'
+require 'opal/nil_class'
+require 'opal/boolean'
+require 'opal/error'
+require 'opal/regexp'
+require 'opal/comparable'
+require 'opal/enumerable'
+require 'opal/enumerator'
+require 'opal/array'
+require 'opal/hash'
+require 'opal/string'
+require 'opal/numeric'
+require 'opal/proc'
+require 'opal/range'
+require 'opal/time'
+require 'opal/json'
+require 'opal/native'
 
 # regexp matches
 $~ = nil

data/opal/opal/array.rb

@@ -86,7 +86,7 @@ class Array < `Array`
   end
 
   def +(other)
-    `#{self}.slice().concat(other.slice())`
+    `#{self}.concat(other)`
   end
 
   def -(other)

data/opal/opal/class.rb

@@ -146,13 +146,18 @@ class Class
       var result = #{self}._scope[name];
 
       if (result == null) {
-        #{ raise NameError, "uninitialized constant #{name}" }
+        return #{ const_missing name };
       }
 
       return result;
     }
   end
 
+  def const_missing(const)
+    name = `#{self}._name`
+    raise NameError, "uninitialized constant #{name}::#{const}"
+  end
+
   def const_set(name, value)
     raise NameError, "wrong constant name #{name}" unless name =~ /^[A-Z]/
     raise NameError, "wrong constant name #{name}" unless name =~ /^[\w_]+$/

data/opal/opal/kernel.rb

@@ -140,7 +140,7 @@ module Kernel
         } else {
           width = parseInt(width_str, 10);
         }
-        if (prec_str === undefined) {
+        if (!prec_str) {
           prec = is_float_spec ? 6 : undefined;
         } else if (prec_str.charAt(0) == '*') {
           var p_idx = idx++;

data/opal/opal/native.rb

@@ -1,28 +1,114 @@
-module Native
+class Native < BasicObject
+  def self.global
+    @global ||= Native.new(`Opal.global`)
+  end
+
+  def self.[](key)
+    global[key]
+  end
+
   def initialize(native)
     %x{
       if (#{native} == null) {
-        #{ raise "null or undefined passed to Native" };
+        #{ Kernel.raise "null or undefined passed to Native" };
       }
     }
 
     @native = native
   end
 
+  def each(&block)
+    %x{
+      var n = #{@native}, value;
+
+      for (var key in n) {
+        value = n[key];
+
+        if (value == null) {
+          value = nil;
+        }
+        else if (typeof(value) === 'object') {
+          if (!value._klass) {
+            value = #{Native.new `value`};
+          }
+        }
+
+        block(key, value);
+      }
+    }
+  end
+
+  def key? name
+    `#{@native}[name] != null`
+  end
+
   def method_missing(symbol, *args, &block)
     native = @native
 
     %x{
-      var func;
+      var prop = #{native}[#{symbol}];
 
-      if (func = #{native}[#{symbol}]) {
-        return func.call(#{native});
+      if (typeof(prop) === 'function') {
+        prop = prop.apply(#{native}, #{args});
+
+        if (typeof(prop) === 'object' || typeof(prop) === 'function') {
+          if (!prop._klass) {
+            return #{ Native.new `prop` };
+          }
+        }
+
+        return prop;
+      }
+      else if (symbol.charAt(symbol.length - 1) === '=') {
+        prop = symbol.slice(0, symbol.length - 1);
+        return #{native}[prop] = args[0];
+      }
+      else if (prop != null) {
+        if (typeof(prop) === 'object') {
+          if (!prop._klass) {
+            return #{Native.new `prop`};
+          }
+        }
+        return prop;
       }
     }
 
     nil
   end
 
+  def [](key)
+    %x{
+      var value = #{@native}[key];
+
+      if (value == null) return #{nil};
+
+      return value;
+    }
+  end
+
+  def ==(other)
+    `#{@native} === #{other}.native`
+  end
+
+  def to_a
+    %x{
+      var n = #{@native}, result;
+
+      if (n.length) {
+        result = [];
+
+        for (var i = 0, len = n.length; i < len; i++) {
+          result.push(#{ Native.new `n[i]` });
+        }
+      }
+      else {
+        result = [n];
+      }
+
+      return result;
+    }
+  end
+
   def to_native
     @native
   end

data/opal/opal/runtime.js

@@ -72,6 +72,7 @@
       var const_alloc   = function() {};
       var const_scope   = const_alloc.prototype = new base._scope.alloc();
       klass._scope      = const_scope;
+      const_scope.base  = klass;
       const_scope.alloc = const_alloc;
 
       base[id] = base._scope[id] = klass;
@@ -236,19 +237,22 @@
 
   Opal.puts = function(a) { console.log(a); };
 
+  var mm_mid = '';
+
+  var method_missing_dispatcher = function() {
+    this.$method_missing._p = method_missing_dispatcher._p;
+    return this.$method_missing.apply(this, [mm_mid].concat(__slice.call(arguments)));
+  };
+
   // Method missing dispatcher
   Opal.mm = function(mid) {
-    var dispatcher = function() {
-      this.$method_missing._p = dispatcher._p;
-      return this.$method_missing.apply(this, [mid].concat(__slice.call(arguments)));
-    };
-
-    return dispatcher;
+    mm_mid = mid;
+    return method_missing_dispatcher;
   };
 
   // Const missing dispatcher
   Opal.cm = function(name) {
-    throw Opal.NameError.$new('uninitialized constant ' + name);
+    return this.base.$const_missing(name);
   };
 
   // Arity count error dispatcher
@@ -256,7 +260,33 @@
     var inspect = (object._isObject ? object._klass._name + '#' : object._name + '.') + meth;
     var msg = '[' + inspect + '] wrong number of arguments(' + actual + ' for ' + expected + ')'
     throw Opal.ArgumentError.$new(msg);
-  }
+  };
+
+  /*
+    Call a ruby method on a ruby object with some arguments:
+
+      var my_array = [1, 2, 3, 4]
+      Opal.send(my_array, 'length')     # => 4
+      Opal.send(my_array, 'reverse!')   # => [4, 3, 2, 1]
+
+    A missing method will be forwarded to the object via
+    method_missing.
+
+    The result of either call with be returned.
+
+    @param [Object] recv the ruby object
+    @param [String] mid ruby method to call
+  */
+  Opal.send = function(recv, mid) {
+    var args = __slice.call(arguments, 2),
+        func = recv['$' + mid];
+
+    if (func) {
+      return func.apply(recv, args);
+    }
+
+    return recv.$method_missing.apply(recv, [mid].concat(args));
+  };
 
   // Initialization
   // --------------
@@ -343,6 +373,7 @@
 
   var bridged_classes = Object.$included_in = [];
 
+  Opal.base = Object;
   BasicObject._scope = Object._scope = Opal;
   Opal.Module = Opal.Class;
   Opal.Kernel = Object;

data/spec/opal/browser/local_storage_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'opal-browser/local_storage'
+
+describe Browser::LocalStorage do
+  before do
+    @storage = Browser::LocalStorage
+    @storage.clear
+  end
+
+  describe '.[]' do
+    it 'returns nil when accessing an undefined value' do
+      @storage['woosh'].should be_nil
+    end
+
+    it 'returns an empty string when set value was also ""' do
+      @storage['empty'] = ''
+      @storage['empty'].should == ''
+    end
+  end
+
+  describe '.[]=' do
+    it 'sets values in the localstorage' do
+      @storage['foo'] = 'Hello World'
+      @storage['foo'].should == 'Hello World'
+    end
+
+    it 'stores all values as strings' do
+      @storage['foo'] = 3.142
+      @storage['foo'].should be_kind_of(String)
+    end
+  end
+
+  describe '.clear' do
+    it 'removes all values from the store' do
+      @storage['foo'] = 'wow'
+      @storage['bar'] = 'pow'
+      @storage.clear
+      @storage['foo'].should be_nil
+      @storage['bar'].should be_nil
+    end
+  end
+
+  describe '.delete' do
+    it 'deletes the given key from localstorage' do
+      @storage['deletable'] = 'Hey there'
+      @storage.delete 'deletable'
+      @storage['deletable'].should be_nil
+    end
+
+    it 'returns the deleted value' do
+      @storage['deletable'] = 'Hey there'
+      @storage.delete('deletable').should == 'Hey there'
+    end
+  end
+end

data/spec/opal/erb/erb_spec.rb

@@ -0,0 +1,31 @@
+require 'erb'
+
+# Our 3 templates we use (we can require them as normal files)
+require 'simple_erb_template'
+require 'templates/prefixed'
+require 'templates/foo/bar'
+
+describe "Opal ERB files" do
+  it "should be defined by their filename on Template namespace" do
+    Template['simple_erb_template'].should be_kind_of(ERB)
+  end
+
+  it "should remove 'templates/' path prefix" do
+    Template['templates/prefixed'].should be_nil
+    Template['prefixed'].should be_kind_of(ERB)
+  end
+
+  it "should maintain '/' in template paths" do
+    Template['foo/bar'].should be_kind_of(ERB)
+  end
+
+  it "calling the block with a context should render the block" do
+    @some_data = "hello"
+    Template['simple_erb_template'].render(self).should == "<div>hello</div>\n"
+  end
+
+  it "should accept quotes in strings" do
+    @name = "adam"
+    Template['foo/bar'].render(self).should == "<div class=\"foo\">hello there adam</div>\n"
+  end
+end

data/spec/opal/eventable_spec.rb

@@ -0,0 +1,75 @@
+require "opal-eventable"
+
+class EventableSpec
+  include Eventable
+
+  attr_reader :events
+end
+
+describe Eventable do
+  describe "#on" do
+    before do
+      @obj = EventableSpec.new
+    end
+
+    it "should register event handlers for given name" do
+      handler = Proc.new {}
+      @obj.on(:foo, &handler)
+      @obj.events[:foo].should == [handler]
+    end
+  end
+
+  describe "#trigger" do
+    before do
+      @obj = EventableSpec.new
+    end
+
+    it "should call handler" do
+      called = false
+
+      @obj.on(:foo) { called = true }
+      called.should == false
+
+      @obj.trigger(:foo)
+      called.should == true
+    end
+
+    it "should pass all arguments to handler" do
+      args = nil
+      @obj.on(:foo) { |*a| args = a }
+
+      @obj.trigger(:foo)
+      args.should == []
+
+      @obj.trigger(:foo, 1)
+      args.should == [1]
+
+      @obj.trigger(:foo, 1, 2, 3)
+      args.should == [1, 2, 3]
+    end
+
+    it "should allow multiple different events to be registered" do
+      result = []
+      @obj.on(:foo) { result << :foo }
+      @obj.on(:bar) { result << :bar }
+
+      @obj.trigger(:foo)
+      result.should == [:foo]
+
+      @obj.trigger(:bar)
+      result.should == [:foo, :bar]
+    end
+
+    it "should allow multiple handlers for an event" do
+      count = 0
+
+      @obj.on(:foo) { count += 1 }
+      @obj.on(:foo) { count += 1 }
+      @obj.on(:foo) { count += 1 }
+      @obj.on(:foo) { count += 1 }
+      @obj.trigger(:foo)
+
+      count.should == 4
+    end
+  end
+end