opal 0.3.2 → 0.3.6

data/gems/core/spec/language/def_spec.rb

@@ -1,21 +0,0 @@
-
-describe "Redefining a method" do
-  
-  it "replaces the original method" do
-    def barFoo; 100; end
-    barFoo.should == 100
-    
-    def barFoo; 200; end
-    barFoo.should == 200
-  end
-end
-
-describe "A singleton method definition" do
-  it "can be declared for a local variable" do
-    a = Object.new
-    def a.foo
-      5
-    end
-    a.foo.should == 5
-  end
-end

data/gems/core/spec/language/eigenclass_spec.rb

@@ -1,60 +0,0 @@
-
-# describe "self in an eigenclass body (class << obj)" do
-#   it "is TrueClass for true" do
-#     class << true; self; end.should == TrueClass
-#   end
-#   
-#   it "is FalseClass for false" do
-#     class << false; self; end.should == FalseClass
-#   end
-#   
-#   it "is NilClass for nil" do
-#     class << nil; self; end.should == NilClass
-#   end
-#   
-#   it "is a singleton Class instance" do
-#     mock = Object.new
-#     cls = class << mock; self; end
-#     cls.is_a?(Class).should == true
-#     # puts cls
-#     # `console.log(#{cls});`
-#   end
-#   
-#   it "is a Class for classes"
-#   
-#   it "inherits from Class for classes" do
-#     temp = []
-#     cls = class << Object; self; end
-#     sc = cls
-#     until sc.nil? || sc.superclass == sc
-#       temp << sc
-#       sc = sc.superclass
-#     end
-#     temp.should include(Class)
-#   end
-# end
-
-
-# puts "testing eigenclass etc"
-# 
-# class EigenclassSpecTest
-#   
-#   def something=(something)
-#     puts "setting something to #{something}"
-#   end
-# end
-# 
-# a = EigenclassSpecTest.new
-# a.something = 100
-# 
-# a_class = class << a; self; end
-# 
-# a_class.define_method(:something=) do |value|
-#   puts "setting something.."
-#   super value
-#   puts "did set something"
-# end
-# 
-# # `console.log(#{a}['$something=']);`
-# 
-# a.something = 200

data/gems/core/spec/language/file_spec.rb

@@ -1,13 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-# specs for __FILE__
-
-describe "The __FILE__ constant" do
-  it "equals the current filename" do
-    File.basename(__FILE__).should == "file_spec.rb"
-  end
-  
-  it "equals (eval) inside an eval" do
-    # eval("__FILE__").should == "(eval)"
-  end
-end

data/gems/core/spec/language/fixtures/block.rb

@@ -1,21 +0,0 @@
-puts "in block fixtures"
-
-module BlockSpecs
-  class Yield
-    def splat(*args)
-      yield *args
-    end
-    
-    def two_args
-      yield 1, 2
-    end
-    
-    def two_arg_array
-      yield [1, 2]
-    end
-    
-    def yield_splat_inside_block
-      [1, 2].send(:each_with_index) { |*args| yield(*args) }
-    end
-  end
-end

data/gems/core/spec/language/fixtures/super.rb

@@ -1,293 +0,0 @@
-module Super
-  module S1
-    class A
-      def foo(a)
-        a << "A#foo"
-        bar(a)
-      end
-      def bar(a)
-        a << "A#bar"
-      end
-    end
-    class B < A
-      def foo(a)
-        a << "B#foo"
-        super(a)
-      end
-      def bar(a)
-        a << "B#bar"
-        super(a)
-      end
-    end
-  end
-  
-  module S2
-    class A
-      def baz(a)
-        a << "A#baz"
-      end
-    end
-    class B < A
-      def foo(a)
-        a << "B#foo"
-        baz(a)
-      end
-    end
-    class C < B
-      def baz(a)
-        a << "C#baz"
-        super(a)
-      end
-    end
-  end
-  
-  module S3
-    class A
-      def foo(a)
-        a << "A#foo"
-      end
-      def self.foo(a)
-        a << "A::foo"
-      end
-      def self.bar(a)
-        a << "A::bar"
-        foo(a)
-      end
-    end
-    class B < A
-      def self.foo(a)
-        a << "B::foo"
-        super(a)
-      end
-      def self.bar(a)
-        a << "B::bar"
-        super(a)
-      end
-    end
-  end
-  
-  module S4
-    class A
-      def foo(a)
-        a << "A#foo"
-      end
-    end
-    class B < A
-      def foo(a, b)
-        a << "B#foo(a,#{b})"
-        super(a)
-      end
-    end
-  end
-
-  class S5
-    def here
-      :good
-    end
-  end
-
-  class S6 < S5
-    def under
-      yield
-    end
-
-    def here
-      under {
-        super
-      }
-    end
-  end
-
-  class S7 < S5
-    define_method(:here) { super() }
-  end
-
-  module MS1
-    module ModA
-      def foo(a)
-        a << "ModA#foo"
-        bar(a)
-      end      
-      def bar(a)
-        a << "ModA#bar"
-      end
-    end
-    class A
-      include ModA
-    end
-    module ModB
-      def bar(a)
-        a << "ModB#bar"
-        super(a)
-      end
-    end
-    class B < A    
-      def foo(a)
-        a << "B#foo"
-        super(a)
-      end
-      include ModB
-    end
-  end
-  # 
-  # module MS2
-  #   class A
-  #     def baz(a)
-  #       a << "A#baz"
-  #     end
-  #   end
-  #   module ModB
-  #     def foo(a)
-  #       a << "ModB#foo"
-  #       baz(a)
-  #     end
-  #   end
-  #   class B < A
-  #     include ModB
-  #   end
-  #   class C < B
-  #     def baz(a)
-  #       a << "C#baz"
-  #       super(a)
-  #     end
-  #   end
-  # end
-  # 
-  # module MS3
-  #   module ModA
-  #     def foo(a)
-  #       a << "ModA#foo"
-  #     end
-  #     def bar(a)
-  #       a << "ModA#bar"
-  #       foo(a)
-  #     end
-  #   end
-  #   class A
-  #     def foo(a)
-  #       a << "A#foo"
-  #     end
-  #     class << self
-  #       include ModA
-  #     end
-  #   end
-  #   class B < A
-  #     def self.foo(a)
-  #       a << "B::foo"
-  #       super(a)
-  #     end
-  #     def self.bar(a)
-  #       a << "B::bar"
-  #       super(a)
-  #     end
-  #   end
-  # end  
-  # 
-  # module MS4
-  #   module Layer1
-  #     def example
-  #       5
-  #     end
-  #   end
-  # 
-  #   module Layer2
-  #     include Layer1
-  #     def example
-  #       super
-  #     end
-  #   end
-  # 
-  #   class A
-  #     include Layer2
-  #     public :example
-  #   end
-  # end
-
-  # class MM_A
-  #    undef_method :is_a?
-  #  end
-  # 
-  #  class MM_B < MM_A
-  #    def is_a?(blah)
-  #      # should fire the method_missing below
-  #      super
-  #    end
-  # 
-  #    def method_missing(*)
-  #      false
-  #    end
-  #  end
-  # 
-  #  class Alias1
-  #    def name
-  #      [:alias1]
-  #    end
-  #  end
-  # 
-  #  class Alias2 < Alias1
-  #    def initialize
-  #      @times = 0
-  #    end
-  # 
-  #    def name
-  #      if @times >= 10
-  #        raise "runaway super"
-  #      end
-  # 
-  #      @times += 1
-  # 
-  #      # Use this so that we can see collect all supers that we see.
-  #      # One bug that arises is that we call Alias2#name from Alias2#name
-  #      # as it's superclass. In that case, either we get a runaway recursion
-  #      # super OR we get the return value being [:alias2, :alias2, :alias1]
-  #      # rather than [:alias2, :alias1].
-  #      #
-  #      # Which one depends on caches and how super is implemented.
-  #      [:alias2] + super
-  #    end
-  #  end
-  # 
-  #  class Alias3 < Alias2
-  #    alias_method :name3, :name
-  #    # In the method table for Alias3 now should be a special alias entry
-  #    # that references Alias2 and Alias2#name (probably as an object).
-  #    #
-  #    # When name3 is called then, Alias2 (NOT Alias3) is presented as the
-  #    # current module to Alias2#name, so that when super is called,
-  #    # Alias2->superclass is next.
-  #    #
-  #    # Otherwise, Alias2 is next, which is where name was to begin with,
-  #    # causing the wrong #name method to be called.
-  #  end
-  # 
-  #  module AliasWithSuper
-  #    module AS1
-  #      def foo
-  #        :a
-  #      end
-  #    end
-  # 
-  #    module BS1
-  #      def foo
-  #        [:b, super]
-  #      end
-  #    end
-  # 
-  #    class Base
-  #      extend AS1
-  #      extend BS1
-  #    end
-  # 
-  #    class Trigger < Base
-  #      class << self
-  #        def foo_quux
-  #          foo_baz
-  #        end
-  # 
-  #        alias_method :foo_baz, :foo
-  #        alias_method :foo, :foo_quux
-  #      end
-  #    end
-  #  end
-  
-end

data/gems/core/spec/language/hash_spec.rb

@@ -1,29 +0,0 @@
-
-describe "Hash literal" do
-  it "{} should return an empty hash" do
-    {}.size.should == 0
-    {}.should == {}
-  end
-  
-  it "{} should return a new hash populated with the given elements" do
-    h = { :a => 'a', 'b' => 3, 44 => 2.3 }
-    h.size.should == 3
-    h.should == { :a => 'a', 'b' => 3, 44 => 2.3 }
-  end
-  
-  it "treats empty expressions as nils" do
-    h = {() => ()}
-    h.keys.should == [nil]
-    h.values.should == [nil]
-    
-    h = {() => :value}
-    h.keys.should == [nil]
-    h.values.should == [:value]
-    h[nil].should == :value
-    
-    h = {:key => ()}
-    h.keys.should == [:key]
-    h.values.should == [nil]
-    h[:key].should == nil
-  end
-end

data/gems/core/spec/language/if_spec.rb

@@ -1,54 +0,0 @@
-# 
-# describe "The if expression" do
-#   it "evaluates body if expression is true" do
-#     a = []
-#     if true
-#       a << 123
-#     end
-#     a.should == [123]
-#   end
-#   
-#   it "does not evaluate body if expression is false" do
-#     a = []
-#     if false
-#       a << 123
-#     end
-#     a.should == []
-#   end
-#   
-#   it "does not evaluate body if expression is empty" do
-#     a = []
-#     if ()
-#       a << 123
-#     end
-#     a.should == []
-#   end
-#   
-#   it "does not evaluate else body if expression is true" do
-#     a = []
-#     if true
-#       a << 123
-#     else
-#       a << 456
-#     end
-#     a.should == [123]
-#   end
-#   
-#   it "evaluates only else-body if expression is false" do
-#     a = []
-#     if false
-#       a << 123
-#     else
-#       a << 456
-#     end
-#     a.should == [456]
-#   end
-#   
-#   it "returns result of then-body evaluation if expression is true" do
-#     # raise "this causes error: return is injected before if = javascript error"
-#     # if true
-#       # 123
-#     # end.should == 456
-#   end
-# end
-