opal 0.3.43 → 0.3.44

data/opal/opal-eventable.rb

@@ -1,26 +0,0 @@
-# A simple event registering/triggering module to mix into classes.
-# Events are stored in the `@events` ivar.
-module Eventable
-
-  # Register a handler for the given event name.
-  #
-  #   obj.on(:foo) { puts "foo was called" }
-  #
-  # @param [String, Symbol] name event name
-  def on(name, &handler)
-    @events ||= Hash.new { |hash, key| hash[key] = [] }
-    @events[name] << handler
-  end
-
-  # Trigger the given event name and passes all args to each handler
-  # for this event.
-  #
-  #   obj.trigger(:foo)
-  #   obj.trigger(:foo, 1, 2, 3)
-  #
-  # @param [String, Symbol] name event name to trigger
-  def trigger(name, *args)
-    @events ||= Hash.new { |hash, key| hash[key] = [] }
-    @events[name].each { |handler| handler.call(*args) }
-  end
-end

data/opal/opal/native.rb

@@ -1,115 +0,0 @@
-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) {
-        #{ 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 prop = #{native}[#{symbol}];
-
-      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
-end

data/spec/opal/eventable_spec.rb

@@ -1,75 +0,0 @@
-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

data/spec/opal/native/element_reference_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe "Native#[]" do
-  before do
-    %x{
-      var obj = {
-        foo: 'FOO',
-
-        str: 'LOL',
-        num: 42,
-        on: true,
-        off: false
-      };
-    }
-
-    @native = Native.new(`obj`)
-  end
-
-  it "returns a value from the native object" do
-    @native['foo'].should == "FOO"
-  end
-
-  it "returns nil for a key not existing on native object" do
-    @native['bar'].should be_nil
-  end
-
-  it "returns direct values for strings, numerics and booleans" do
-    @native['str'].should == 'LOL'
-    @native['num'].should == 42
-    @native['on'].should == true
-    @native['off'].should == false
-  end
-end
-
-describe "Native.[]" do
-  it "accesses properties on Native.global" do
-    Native.global.some_random_property_we_should_remove = 42
-    Native['some_random_property_we_should_remove'].should == 42
-  end
-end

data/spec/opal/native/equal_spec.rb

@@ -1,17 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Native#==" do
-  it "returns true if the wrapped objects are `===` to each other" do
-    %x{
-      var obj1 = {}, obj2 = {};
-    }
-
-    a = Native.new(`obj1`)
-    b = Native.new(`obj1`)
-    c = Native.new(`obj2`)
-
-    (a == b).should be_true
-    (a == c).should be_false
-  end
-end

data/spec/opal/native/fixtures/classes.rb

@@ -1,27 +0,0 @@
-module NativeSpecs
-  %x{
-    var obj = {
-      property: 42,
-
-      simple: function() {
-        return 'foo';
-      },
-
-      context_check: function() {
-        return this === obj;
-      },
-
-      check_args: function(a, b, c) {
-        return [a, b, c];
-      },
-
-      array: [1, 2, 3, 4],
-
-      child_object: {
-        grand_child: 100
-      }
-    };
-  }
-
-  OBJ = Native.new(`obj`)
-end

data/spec/opal/native/global_spec.rb

@@ -1,12 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Native#global" do
-  it "is an instance of Native" do
-    (Native === Native.global).should be_true
-  end
-
-  it "wraps Opal.global" do
-    (Native.global == Native.new(`Opal.global`)).should be_true
-  end
-end

data/spec/opal/native/initialize_spec.rb

@@ -1,8 +0,0 @@
-require "spec_helper"
-
-describe "Native#initialize" do
-  it "raises an error when passed null or undefined" do
-    lambda { Native.new(`null`) }.should raise_error(Exception)
-    lambda { Native.new(`undefined`) }.should raise_error(Exception)
-  end
-end

data/spec/opal/native/method_missing_spec.rb

@@ -1,53 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Native#method_missing" do
-  before do
-    @obj = NativeSpecs::OBJ
-  end
-
-  describe "accessing a null/undefined property" do
-    it "returns nil" do
-      @obj.doesnt_exist.should == nil
-    end
-  end
-
-  describe "with a mid ending with '='" do
-    it "sets the value on the property" do
-      @obj.set_property = 100
-      @obj.set_property.should == 100
-
-      @obj.set_property = [1, 2, 3]
-      @obj.set_property.should == [1, 2, 3]
-    end
-  end
-
-  describe "accessing a property" do
-    it "returns values from the native object" do
-      @obj.property.should == 42
-    end
-
-    it "returns an array without wrapping" do
-      @obj.array.should == [1, 2, 3, 4]
-    end
-
-    it "returns the property in a new Native object if a js object" do
-      res = @obj.child_object
-      (Native === res).should be_true
-    end
-  end
-
-  describe "accessing a function property" do
-    it "forwards methods to wrapped object as native function calls" do
-      @obj.simple.should == "foo"
-    end
-
-    it "calls functions with native object as context" do
-      @obj.context_check.should be_true
-    end
-
-    it "passes each argument to native function" do
-      @obj.check_args(1, 2, 3).should == [1, 2, 3]
-    end
-  end
-end

data/spec/opal/native/to_native_spec.rb

@@ -1,8 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Native#to_native" do
-  it "returns the wrapped object" do
-    Native.new(:foo).to_native.should == :foo
-  end
-end

data/spec/rubyspec/core/string/demodulize_spec.rb

@@ -1,10 +0,0 @@
-describe "String#demodulize" do
-  it "removes any preceding module name from the string" do
-    "Foo::Bar".demodulize.should == "Bar"
-    "Foo::Bar::Baz".demodulize.should == "Baz"
-  end
-  
-  it "has no affect on strings with no module seperator" do
-    "SomeClassName".demodulize.should == "SomeClassName"
-  end
-end

data/spec/rubyspec/core/string/underscore_spec.rb

@@ -1,17 +0,0 @@
-describe "String#underscore" do
-  it "replaces '-' in dasherized strings with underscores" do
-    "well-hello-there".underscore.should == "well_hello_there"
-  end
-  
-  it "converts single all-upcase strings into lowercase" do
-    "OMG".underscore.should == "omg"
-  end
-  
-  it "splits word bounderies and seperates using underscore" do
-    "AdamBeynon".underscore.should == "adam_beynon"
-  end
-  
-  it "does not split when 2 or more capitalized letters together" do
-    "HTMLParser".underscore.should == "html_parser"
-  end
-end