opal 0.4.3 → 0.4.4

data/spec/rubyspec/language/versions/array_1.9.rb

@@ -14,7 +14,7 @@ describe "Array literals" do
 end
 
 describe "The unpacking splat operator (*)" do
-  pending "when applied to a non-Array value attempts to coerce it to Array if the object respond_to?(:to_a)" do
+  it "when applied to a non-Array value attempts to coerce it to Array if the object respond_to?(:to_a)" do
     obj = mock("pseudo-array")
     obj.should_receive(:to_a).and_return([2, 3, 4])
     [1, *obj].should == [1, 2, 3, 4]

data/spec/rubyspec/language/versions/literal_lambda_1.9.rb

@@ -34,7 +34,7 @@ describe "->(){}" do
     "1+2=#{->{ 1 + 2}.call}".should == "1+2=3"
   end
 
-  pending "can be be used as a Hash key" do
+  it "can be be used as a Hash key" do
     h = new_hash
     # h[->(one=1){ one + 2}.call] = :value
     h.key?(3).should be_true
@@ -71,51 +71,51 @@ describe "->(){}" do
     ->(a,b) {[a, b]}.call(:sym, :bol).should == [:sym, :bol]
   end
 
-  pending "accepts parameters with default parameters between the parenthesis" do
+  it "accepts parameters with default parameters between the parenthesis" do
     # lambda { ->(a=1) {} }.should_not raise_error(SyntaxError)
     # lambda { ->(x=1, b=[]) {} }.should_not raise_error(SyntaxError)
   end
 
-  pending "aliases each argument with a default value to the corresponding parameter" do
+  it "aliases each argument with a default value to the corresponding parameter" do
     # ->(a=:cymbal) {a}.call(:sym).should == :sym
     # ->(a,b=:cymbal) {[a, b]}.call(:sym, :bol).should == [:sym, :bol]
   end
 
-  pending "sets arguments to their default value if one wasn't supplied" do
+  it "sets arguments to their default value if one wasn't supplied" do
     # ->(a=:cymbal) {a}.call.should == :cymbal
     # ->(a,b=:cymbal) {[a, b]}.call(:sym).should == [:sym, :cymbal]
   end
 
-  pending "accepts a parameter prefixed with an asterisk between the parenthesis" do
+  it "accepts a parameter prefixed with an asterisk between the parenthesis" do
     # lambda { ->(*a) {} }.should_not raise_error(SyntaxError)
     # lambda { ->(x, *a) {} }.should_not raise_error(SyntaxError)
   end
 
-  pending "assigns all remaining arguments to the variable in the parameter list prefixed with an asterisk, if one exists" do
+  it "assigns all remaining arguments to the variable in the parameter list prefixed with an asterisk, if one exists" do
     # ->(*a) {a}.call(:per, :cus, :si, :on).should == [:per, :cus, :si, :on]
     # ->(a,*b) {b}.call(:per, :cus, :si, :on).should == [:cus, :si, :on]
   end
 
-  pending "accepts a parameter prefixed with an ampersand between the parenthesis" do
+  it "accepts a parameter prefixed with an ampersand between the parenthesis" do
     # lambda { ->(&a) {} }.should_not raise_error(SyntaxError)
     # lambda { ->(x, &a) {} }.should_not raise_error(SyntaxError)
   end
 
-  pending "assigns the given block to the parameter prefixed with an ampersand if such a parameter exists" do
+  it "assigns the given block to the parameter prefixed with an ampersand if such a parameter exists" do
     # l = ->(&a) { a }.call { :foo }
     l.call.should == :foo
   end
 
-  pending "assigns nil to the parameter prefixed with an ampersand unless a block was supplied" do
+  it "assigns nil to the parameter prefixed with an ampersand unless a block was supplied" do
     # ->(&a) { a }.call.should be_nil
   end
 
-  pending "accepts a combination of argument types between the parenthesis" do
+  it "accepts a combination of argument types between the parenthesis" do
     # lambda { ->(x, y={}, z  = Object.new, *a, &b) {} }.
       should_not raise_error(SyntaxError)
   end
 
-  pending "sets parameters appropriately when a combination of parameter types is given between the parenthesis" do
+  it "sets parameters appropriately when a combination of parameter types is given between the parenthesis" do
     # l = ->(x, y={}, z  = Object.new, *a, &b) { [x,y,z,a,b]}
     l.call(1, [], [], 30, 40).should == [1, [], [], [30, 40], nil]
     block = lambda { :lamb }
@@ -124,7 +124,7 @@ describe "->(){}" do
     l2.call(:x).should == [:x, {}, []]
   end
 
-  pending "uses lambda's 'rigid' argument handling" do
+  it "uses lambda's 'rigid' argument handling" do
     ->(a, b){}.parameters.first.first.should == :req
     ->(a, b){}.parameters.last.first.should == :req
     lambda { ->(a, b){}.call 1 }.should raise_error(ArgumentError)

data/spec/rubyspec/language/versions/send_1.9.rb

@@ -7,7 +7,7 @@ specs = LangSendSpecs
 
 describe "Invoking a method" do
   describe "with required args after the rest arguments" do
-    pending "binds the required arguments first" do
+    it "binds the required arguments first" do
       specs.fooM0RQ1(1).should == [[], 1]
       specs.fooM0RQ1(1,2).should == [[1], 2]
       specs.fooM0RQ1(1,2,3).should == [[1,2], 3]
@@ -27,7 +27,7 @@ describe "Invoking a method" do
   end
 
   describe "with manditory arguments after optional arguments" do
-    pending "binds the required arguments first" do
+    it "binds the required arguments first" do
       specs.fooO1Q1(0,1).should == [0,1]
       specs.fooO1Q1(2).should == [1,2]
 
@@ -54,7 +54,7 @@ describe "Invoking a method" do
     end
   end
 
-  pending "with .() invokes #call" do
+  it "with .() invokes #call" do
     q = proc { |z| z }
     q.(1).should == 1
 
@@ -63,11 +63,11 @@ describe "Invoking a method" do
     obj.().should == :called
   end
 
-  pending "allows a vestigial trailing ',' in the arguments" do
+  it "allows a vestigial trailing ',' in the arguments" do
     # specs.fooM1(1,).should == [1]
   end
 
-  pending "with splat operator attempts to coerce it to an Array if the object respond_to?(:to_a)" do
+  it "with splat operator attempts to coerce it to an Array if the object respond_to?(:to_a)" do
     ary = [2,3,4]
     obj = mock("to_a")
     obj.should_receive(:to_a).and_return(ary).twice
@@ -75,7 +75,7 @@ describe "Invoking a method" do
     specs.fooM1R(1,*obj).should == [1, ary]
   end
 
-  pending "with splat operator * and non-Array value uses value unchanged if it does not respond_to?(:to_ary)" do
+  it "with splat operator * and non-Array value uses value unchanged if it does not respond_to?(:to_ary)" do
     obj = Object.new
     obj.should_not respond_to(:to_a)
 
@@ -89,44 +89,44 @@ describe "Invoking a method" do
     specs.fooM4(0,*a,3).should == [0,1,2,3]
   end
 
-  pending "accepts final explicit literal Hash arguments after the splat" do
+  it "accepts final explicit literal Hash arguments after the splat" do
     a = [1, 2]
     specs.fooM0RQ1(*a, { :a => 1 }).should == [[1, 2], { :a => 1 }]
   end
 
-  pending "accepts final implicit literal Hash arguments after the splat" do
+  it "accepts final implicit literal Hash arguments after the splat" do
     a = [1, 2]
     specs.fooM0RQ1(*a, :a => 1).should == [[1, 2], { :a => 1 }]
   end
 
-  pending "accepts final Hash arguments after the splat" do
+  it "accepts final Hash arguments after the splat" do
     a = [1, 2]
     b = { :a => 1 }
     specs.fooM0RQ1(*a, b).should == [[1, 2], { :a => 1 }]
   end
 
-  pending "accepts mandatory and explicit literal Hash arguments after the splat" do
+  it "accepts mandatory and explicit literal Hash arguments after the splat" do
     a = [1, 2]
     specs.fooM0RQ2(*a, 3, { :a => 1 }).should == [[1, 2], 3, { :a => 1 }]
   end
 
-  pending "accepts mandatory and implicit literal Hash arguments after the splat" do
+  it "accepts mandatory and implicit literal Hash arguments after the splat" do
     a = [1, 2]
     specs.fooM0RQ2(*a, 3, :a => 1).should == [[1, 2], 3, { :a => 1 }]
   end
 
-  pending "accepts mandatory and Hash arguments after the splat" do
+  it "accepts mandatory and Hash arguments after the splat" do
     a = [1, 2]
     b = { :a => 1 }
     specs.fooM0RQ2(*a, 3, b).should == [[1, 2], 3, { :a => 1 }]
   end
 
-  pending "converts a final splatted explicit Hash to an Array" do
+  it "converts a final splatted explicit Hash to an Array" do
     a = [1, 2]
     specs.fooR(*a, 3, *{ :a => 1 }).should == [1, 2, 3, [:a, 1]]
   end
 
-  pending "calls #to_a to convert a final splatted Hash object to an Array" do
+  it "calls #to_a to convert a final splatted Hash object to an Array" do
     a = [1, 2]
     b = { :a => 1 }
     b.should_receive(:to_a).and_return([:a, 1])
@@ -134,7 +134,7 @@ describe "Invoking a method" do
     specs.fooR(*a, 3, *b).should == [1, 2, 3, :a, 1]
   end
 
-  pending "accepts multiple splat expansions in the same argument list" do
+  it "accepts multiple splat expansions in the same argument list" do
     a = [1,2,3]
     b = 7
     c = mock("pseudo-array")
@@ -146,19 +146,19 @@ describe "Invoking a method" do
     specs.rest_len(0,*a,4,*5,6,7,*c,-1).should == 11
   end
 
-  pending "expands an array to arguments grouped in parentheses" do
+  it "expands an array to arguments grouped in parentheses" do
     specs.destructure2([40,2]).should == 42
   end
 
-  pending "expands an array to arguments grouped in parentheses and ignores any rest arguments in the array" do
+  it "expands an array to arguments grouped in parentheses and ignores any rest arguments in the array" do
     specs.destructure2([40,2,84]).should == 42
   end
 
-  pending "expands an array to arguments grouped in parentheses and sets not specified arguments to nil" do
+  it "expands an array to arguments grouped in parentheses and sets not specified arguments to nil" do
     specs.destructure2b([42]).should == [42, nil]
   end
 
-  pending "expands an array to arguments grouped in parentheses which in turn takes rest arguments" do
+  it "expands an array to arguments grouped in parentheses which in turn takes rest arguments" do
     specs.destructure4r([1, 2, 3]).should == [1, 2, [], 3, nil]
     specs.destructure4r([1, 2, 3, 4]).should == [1, 2, [], 3, 4]
     specs.destructure4r([1, 2, 3, 4, 5]).should == [1, 2, [3], 4, 5]
@@ -176,7 +176,7 @@ describe "Invoking a method" do
           [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
       end
 
-      pending "handles a hanging comma without curly braces" do
+      it "handles a hanging comma without curly braces" do
         # specs.fooM1(abc: 123,).should == [{:abc => 123}]
         # specs.fooM1(rbx: 'cool', specs: :fail_sometimes, non_sym: 1234,).should ==
           # [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
@@ -194,7 +194,7 @@ describe "Invoking a method" do
           ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
       end
 
-      pending "handles a hanging comma without curly braces" do
+      it "handles a hanging comma without curly braces" do
         # specs.fooM3('abc', 123, abc: 123,).should == ['abc', 123, {:abc => 123}]
         # specs.fooM3('abc', 123, rbx: 'cool', specs: :fail_sometimes, non_sym: 1234,).should ==
           # ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
@@ -214,7 +214,7 @@ describe "Invoking a method" do
           [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
       end
 
-      pending "handles a hanging comma without curly braces" do
+      it "handles a hanging comma without curly braces" do
         # specs.fooM1(rbx: 'cool', specs: :fail_sometimes, :non_sym => 1234,).should ==
           # [{ :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
       end
@@ -231,7 +231,7 @@ describe "Invoking a method" do
           ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
       end
 
-      pending "handles a hanging comma without curly braces" do
+      it "handles a hanging comma without curly braces" do
         # specs.fooM3('abc', 123, rbx: 'cool', specs: :fail_sometimes, :non_sym => 1234,).should ==
           # ['abc', 123, { :rbx => 'cool', :specs => :fail_sometimes, :non_sym => 1234 }]
       end

data/spec/rubyspec/language/versions/symbol_1.9.rb

@@ -1,12 +1,12 @@
 describe "A Symbol literal" do
-  pending "can be an empty string" do
+  it "can be an empty string" do
     c = :''
     c.should be_kind_of(Symbol)
     c.inspect.should == ':""'
   end
 
   # These weren't allowed on 1.8
-  pending "can be :!, :!=, or :!~" do
+  it "can be :!, :!=, or :!~" do
     %w{'!', '!=', '!~'}.each do |sym|
       lambda { sym.to_sym }.should_not raise_error(SyntaxError)
       sym.to_sym.to_s.should == sym

data/spec/rubyspec/language/versions/variables_1.9.rb

@@ -1,5 +1,5 @@
 describe "Multiple assignments with splats" do
-  pending "* on the LHS has to be applied to any parameter" do
+  it "* on the LHS has to be applied to any parameter" do
     # a, *b, c = 1, 2, 3
     a.should == 1
     b.should == [2]

data/spec/rubyspec/language/while_spec.rb

@@ -196,7 +196,7 @@ describe "The while modifier with begin .. end block" do
     (begin; break; end while true).should == nil
   end
 
-  pending "runs block at least once (even if the expression is false)" do
+  it "runs block at least once (even if the expression is false)" do
     i = 0
     begin
       i += 1
@@ -205,7 +205,7 @@ describe "The while modifier with begin .. end block" do
     i.should == 1
   end
 
-  pending "evaluates condition after block execution" do
+  it "evaluates condition after block execution" do
     a = []
     i = 0
     begin
@@ -214,7 +214,7 @@ describe "The while modifier with begin .. end block" do
     a.should == [0, 1, 2, 3, 4]
   end
 
-  pending "skips to end of body with next" do
+  it "skips to end of body with next" do
     a = []
     i = 0
     begin
@@ -224,7 +224,7 @@ describe "The while modifier with begin .. end block" do
     a.should == [0, 1, 2, 4]
   end
 
-  pending "restarts the current iteration without reevaluting condition with redo" do
+  it "restarts the current iteration without reevaluting condition with redo" do
     a = []
     i = 0
     j = 0

data/spec/rubyspec/language/yield_spec.rb

@@ -16,7 +16,7 @@ describe "The yield call" do
       lambda { @y.z }.should raise_error(LocalJumpError)
     end
 
-    pending "ignores assignment to the explicit block argument and calls the passed block" do
+    it "ignores assignment to the explicit block argument and calls the passed block" do
       @y.ze { 42 }.should == 42
     end
   end
@@ -87,7 +87,7 @@ describe "The yield call" do
     end
 
     ruby_version_is "1.9" do
-      pending "passes no values when give nil as an argument" do
+      it "passes no values when give nil as an argument" do
         @y.r(nil) { |*a| a }.should == []
       end
     end
@@ -120,7 +120,7 @@ describe "The yield call" do
     end
 
     ruby_version_is "1.9" do
-      pending "does not pass an argument value if the splatted argument is nil" do
+      it "does not pass an argument value if the splatted argument is nil" do
         @y.rs(1, 2, nil) { |*a| a }.should == [1, 2]
       end
     end

data/spec/rubyspec/library/erb/util/html_escape_spec.rb

@@ -0,0 +1,10 @@
+require 'erb'
+require File.expand_path('../../../../spec_helper', __FILE__)
+
+describe "ERB::Util.html_escape" do
+  it "escape (& < > \" ') to (&amp; &lt; &gt; &quot; &#39;)" do
+    input = '& < > " \''
+    expected = '&amp; &lt; &gt; &quot; &#39;'
+    ERB::Util.html_escape(input).should == expected
+  end
+end

data/spec/rubyspec/library/singleton/clone_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Singleton#clone" do
+  it "is prevented" do
+    lambda { SingletonSpecs::MyClass.instance.clone }.should raise_error(TypeError)
+  end
+end

data/spec/rubyspec/library/singleton/dup_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Singleton#dup" do
+  it "is prevented" do
+    lambda { SingletonSpecs::MyClass.instance.dup }.should raise_error(TypeError)
+  end
+end

data/spec/rubyspec/library/singleton/fixtures/classes.rb

@@ -0,0 +1,18 @@
+require 'singleton'
+
+module SingletonSpecs
+  class MyClass
+    attr_accessor :data
+    include Singleton
+  end
+
+  class NewSpec
+    include Singleton
+  end
+
+  class MyClassChild < MyClass
+  end
+
+  class NotInstantiated < MyClass
+  end
+end

data/spec/rubyspec/library/singleton/instance_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Singleton.instance" do
+  it "returns an instance of the singleton class" do
+    SingletonSpecs::MyClass.instance.should be_kind_of(SingletonSpecs::MyClass)
+  end
+
+  it "returns the same instance for multiple calls to instance" do
+    SingletonSpecs::MyClass.instance.should equal(SingletonSpecs::MyClass.instance)
+  end
+
+  it "returns an instance of the singleton's subclasses" do
+    SingletonSpecs::MyClassChild.instance.should be_kind_of(SingletonSpecs::MyClassChild)
+  end
+
+  it "returns the same instance for multiple class to instance on subclasses" do
+    SingletonSpecs::MyClassChild.instance.should equal(SingletonSpecs::MyClassChild.instance)
+  end
+
+  it "returns an instance of the singleton's clone" do
+    klone = SingletonSpecs::MyClassChild.clone
+    klone.instance.should be_kind_of(klone)
+  end
+
+  it "returns the same instance for multiple class to instance on clones" do
+    klone = SingletonSpecs::MyClassChild.clone
+    klone.instance.should equal(klone.instance)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,214 @@
+require 'opal'
+require 'opal-parser'
+require 'mspec'
+
+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_parse(str, file='(string)')
+    Opal::Grammar.new.parse str, file
+  end
+
+  def opal_eval_compiled(javascript)
+    `eval(javascript)`
+  end
+
+  def eval(str)
+    code = Opal::Parser.new.parse str
+    `eval(#{code})`
+  end
+
+  alias_method :opal_eval, :eval
+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
+