opal 0.4.3 → 0.4.4

data/corelib/opal/native.rb

@@ -1,31 +0,0 @@
-class Native
-  def self.try_convert(value)
-    %x{
-      if (value == null) {
-        return null;
-      }
-
-      if (value.$to_n) {
-        return value.$to_n()
-      }
-      else if (!value.$object_id) {
-        return value;
-      }
-      else {
-        return null;
-      }
-    }
-  end
-
-  def initialize(native)
-    if (native = Native.try_convert(native)).nil?
-      raise ArgumentError, "the passed value isn't a native"
-    end
-
-    @native = native
-  end
-
-  def to_n
-    @native
-  end
-end

data/spec/opal/class/bridge_class_spec.rb

@@ -1,39 +0,0 @@
-%x{
-  var BridgeClassProto = function() {
-    this.foo = 200;
-  };
-
-  BridgeClassProto.prototype = {
-    bar: 300,
-    baz: 400
-  };
-}
-
-Class.bridge_class :BridgeClassSpec, `BridgeClassProto`
-
-class BridgeClassSpec
-  def get_foo
-    `#{self}.foo`
-  end
-
-  def say_it
-    "hello world"
-  end
-end
-
-describe "Class#bridge_class" do
-  it "should have a superclass of Object" do
-    BridgeClassSpec.superclass.should == Object
-  end
-
-  it "should report instances as kind of bridged class" do
-    obj = `new BridgeClassProto()`
-    obj.class.should == BridgeClassSpec
-  end
-
-  it "should have defined instance methods present on prototype" do
-    obj = `new BridgeClassProto()`
-    obj.get_foo.should == 200
-    obj.say_it.should == "hello world"
-  end
-end

data/spec/opal/native_spec.rb

@@ -1,209 +0,0 @@
-require 'spec_helper'
-
-%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
-    },
-
-    func_returning_null: function() {
-      return null;
-    },
-
-    func_returning_undefined: function() {
-      return undefined;
-    }
-  };
-}
-
-NATIVE_OBJECT_SPEC = `obj`
-
-describe "Native objects" do
-  before do
-    @obj = NATIVE_OBJECT_SPEC
-  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
-
-  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
-
-    it "tries to convert each argument with to_n if defined" do
-      obj, obj2, obj3 = Object.new, Object.new, Object.new
-      def obj.to_n; "foo"; end
-      def obj2.to_n; 42; end
-
-      @obj.check_args(obj, obj2, obj3).should == ["foo", 42, obj3]
-    end
-
-    it "converts null/undefined values to nil from function" do
-      @obj.func_returning_null.should be_nil
-      @obj.func_returning_undefined.should be_nil
-    end
-  end
-
-  describe "#[]" do
-    before do
-      @native = %x{
-        {
-        foo: 'FOO',
-
-        str: 'LOL',
-        num: 42,
-        on: true,
-        off: false
-        };
-      }
-    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 "#[]=" do
-    it "sets values on the receiver object" do
-      object = `{}`
-
-      object["foo"] = 42
-      object["foo"].should == 42
-    end
-
-    it "sets null on the object when nil given as value" do
-      object = `{}`
-
-      object["foo"] = nil
-      `(object.foo === null)`.should be_true
-    end
-  end
-
-  describe "==" do
-    it "returns true if the wrapped objects are `===` to each other" do
-      %x{
-        var obj1 = {}, obj2 = {};
-      }
-
-      a = `obj1`
-      b = `obj1`
-      c = `obj2`
-
-      (a == b).should be_true
-      (a == c).should be_false
-    end
-  end
-
-  describe "each" do
-    describe "with an array-like object" do
-      it "yields each element to block" do
-        object = `{ "0": 3.142, "1": 42, "length": 2 }`
-        result = []
-
-        object.each { |obj| result << obj }
-        result.should == [3.142, 42]
-      end
-
-      it "yields null and undefined values as nil" do
-        object = `{length: 3, 0: null, 1: undefined}`
-        result = []
-
-        object.each { |obj| result << obj }
-        result.should == [nil, nil, nil]
-      end
-    end
-
-    describe "with a normal js object" do
-      it "yields each key-value pair to the block" do
-        object = `{"foo": 3.142, "bar": 42}`
-        result = []
-
-        object.each { |k, v| result << [k, v] }
-        result.should == [["foo", 3.142], ["bar", 42]]
-      end
-
-      it "yields null and undefined values as nil" do
-        object = `{"foo": null, "bar": undefined}`
-        result = []
-
-        object.each { |k, v| result << v }
-        result.should == [nil, nil]
-      end
-    end
-  end
-
-  describe "#to_h" do
-    it "converts a simple js object into a ruby hash" do
-      object = `{"foo": true, "bar": 42}`
-      hash = object.to_h
-
-      hash.should be_kind_of(Hash)
-      hash.should == {"foo" => true, "bar" => 42}
-    end
-
-    it "converts all null and undefined values to nil" do
-      object = `{"a": null, "b": undefined}`
-      object.to_h.should == {"a" => nil, "b" => nil}
-    end
-  end
-end

data/spec/ospec/runner.rb

@@ -1,223 +0,0 @@
-# stdlib
-require 'date'
-require 'observer'
-
-ENV['MSPEC_RUNNER'] = true
-
-class OSpecFilter
-  def self.main
-    @main ||= self.new
-  end
-
-  def initialize
-    @filters = {}
-  end
-
-  def register
-    MSpec.register :exclude, self
-  end
-
-  def ===(description)
-    @filters.has_key? description
-  end
-
-  def register_filters(description, block)
-    instance_eval(&block)
-  end
-
-  def fails(description)
-    @filters[description] = true
-  end
-end
-
-class Object
-  def opal_filter(description, &block)
-    OSpecFilter.main.register_filters(description, block)
-  end
-end
-
-class PhantomFormatter
-  def initialize(out=nil)
-    @exception = @failure = false
-    @exceptions = []
-    @count = 0
-    @examples = 0
-
-    @current_state = nil
-  end
-
-  def register
-    MSpec.register :exception, self
-    MSpec.register :before,    self
-    MSpec.register :after,     self
-    MSpec.register :start,     self
-    MSpec.register :finish,    self
-    MSpec.register :abort,     self
-    MSpec.register :enter,     self
-  end
-
-  def green(str)
-    `console.log('\\033[32m' + str + '\\033[0m')`
-  end
-
-  def red(str)
-    `console.log('\\033[31m' + str + '\\033[0m')`
-  end
-
-  def log(str)
-    `console.log(str)`
-  end
-
-  def exception?
-    @exception
-  end
-
-  def failure?
-    @failure
-  end
-
-  def enter(describe); end
-
-  def before(state=nil)
-    @current_state = nil
-    @failure = @exception = false
-  end
-
-  def exception(exception)
-    @count += 1
-    @failure = @exception ? @failure && exception.failure? : exception.failure?
-    @exception = true
-    @exceptions << exception
-  end
-
-  def after(state = nil)
-    @current_state = nil
-    @examples += 1
-  end
-
-  def start
-    @start_time = Time.now.to_f
-  end
-
-  def finish
-    time = Time.now.to_f - @start_time
-
-    if @exceptions.empty?
-      log "\nFinished"
-      green "#{@examples} examples, #{@count} failures (time taken: #{time})"
-
-      finish_with_code 0
-    else
-      log "\nFailures:"
-
-      @exceptions.each_with_index do |exception, idx|
-        log "\n  #{idx + 1}. #{exception.description}"
-        red "\n    #{exception.message}"
-      end
-
-      log "\nFinished"
-      red "#{@examples} examples, #{@count} failures (time taken: #{time})"
-
-      finish_with_code(1)
-    end
-  end
-
-  def finish_with_code(code)
-    %x{
-      if (typeof(phantom) !== 'undefined') {
-        return phantom.exit(code);
-      }
-      else {
-        window.OPAL_SPEC_CODE = code;
-      }
-    }
-  end
-end
-
-class File
-  def self.expand_path(*a); nil; end
-end
-
-class ExceptionState
-  def initialize(state, location, exception)
-    @exception = exception
-
-    @description = location ? ["An exception occurred during: #{location}"] : []
-    if state
-      @description << "\n" unless @description.empty?
-      @description << state.description
-      @describe = state.describe
-      @it = state.it
-      @description = @description.join ""
-    else
-      @describe = @it = ""
-    end
-  end
-end
-
-module Kernel
-  def opal_eval(str)
-    code = Opal::Parser.new.parse str
-    `eval(#{code})`
-  end
-
-  def opal_parse(str, file='(string)')
-    Opal::Grammar.new.parse str, file
-  end
-
-  def opal_eval_compiled(javascript)
-    `eval(javascript)`
-  end
-
-  def eval(str)
-    opal_eval str
-  end
-end
-
-module Kernel
-  # FIXME: remove
-  def ruby_version_is(*); end
-  def pending(*); end
-  def language_version(*); end
-end
-
-module MSpec
-  def self.opal_runner
-    @env = Object.new
-    @env.extend MSpec
-  end
-end
-
-class OSpecRunner
-  def self.main
-    @main ||= self.new
-  end
-
-  def initialize
-    register
-    run
-  end
-
-  def register
-    formatter = PhantomFormatter.new
-    formatter.register
-
-    OSpecFilter.main.register
-  end
-
-  def run
-    MSpec.opal_runner
-  end
-
-  def will_start
-    MSpec.actions :start
-  end
-
-  def did_finish
-    MSpec.actions :finish
-  end
-end
-
-# As soon as this file loads, tell the runner the specs are starting
-OSpecRunner.main.will_start
-