opal 0.2.2 → 0.3.0

data/{opals/opal/opal → gems/core}/spec/language/def_spec.rb

@@ -8,4 +8,14 @@ describe "Redefining a method" do
     def barFoo; 200; end
     barFoo.should == 200
   end
-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/file_spec.rb

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

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

@@ -0,0 +1,293 @@
+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/metaclass_spec.rb

@@ -0,0 +1,21 @@
+# 
+# describe "self in a metaclass 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 "raises a TypeError for numbers"
+#   
+#   it "raises a TypeError for symbols"
+#   
+#   it "is a singleton Class instance"
+#   
+# end

data/{opals/opal/opal → gems/core}/spec/language/method_spec.rb

@@ -61,4 +61,64 @@ describe "Calling a method" do
     def foo(a); a; end
     foo(()).should == nil
   end
+  
+  it "with block as block argument is ok" do
+    def foo(a, &b); [a, yield(b)] end
+    
+    foo(10) do 200 end.should == [10, 200]
+    foo(10) { 200 }.should == [10, 200]
+  end
+  
+  it "with block argument converts the block to proc" do
+    def makeproc(&b) b end
+      makeproc { "hello" }.call.should == "hello"
+      makeproc { "hello" }.class.should == Proc
+      
+      def proc_caller(&b) b.call end
+      def enclosing_method
+        proc_caller { return :break_return_value }
+        :method_return_value
+      end
+      
+      enclosing_method.should == :break_return_value
+  end
+  
+  it "with same names as existing variables is ok" do
+    foobar = 100
+    
+    def foobar; 200; end
+    
+    foobar.should == 100
+    foobar().should == 200
+  end
+  
+  it "with splat operator * and literal array unpacks params" do
+    def fooP3(a, b, c); [a, b, c]; end
+    
+    fooP3(*[1, 2, 3]).should == [1, 2, 3]
+  end
+  
+  it "with splat operator * and references array unpacks params" do
+    def fooP3(a,b,c); [a,b,c] end
+    
+    a = [1,2,3]
+    fooP3(*a).should == [1,2,3]
+  end
+  
+  it "without parentheses works" do
+    def fooP3(a,b,c); [a,b,c] end
+    
+    (fooP3 1,2,3).should == [1,2,3]
+  end
+  
+  it "with a space separating method name and parenthesis treats expression in parenthesis as first argument" do
+    def myfoo(x); x * 2 end
+    def mybar
+      # means myfoo((5).to_s)
+      # NOT   (myfoo(5)).to_s
+      # myfoo (5).to_s
+    end
+    
+    # mybar().should == "55"
+  end
 end