opal-wedge 0.9.0.dev

data/spec/opal/core/language/versions/symbol_1.9.rb

@@ -0,0 +1,15 @@
+describe "A Symbol literal" 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
+  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
+    end
+  end
+end

data/spec/opal/core/language/versions/variables_1.9.rb

@@ -0,0 +1,8 @@
+describe "Multiple assignments with splats" 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]
+    c.should == 3
+  end
+end

data/spec/opal/core/language_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "begin & rescue blocks" do
+  it "should evaluate to begin blocks last expression when no exception" do
+    result = begin
+      "a"
+    rescue
+      "b"
+    end
+
+    result.should == "a"
+  end
+
+  it "should evaluate to rescue blocks last expression when exception" do
+    result = begin
+      raise "foo"
+    rescue
+      "bar"
+    end
+
+    result.should == "bar"
+  end
+end

data/spec/opal/core/method/to_proc_spec.rb

@@ -0,0 +1,28 @@
+describe "Method#to_proc" do
+
+  it "returns a Proc object that is bound to the method's receiver" do
+    "hello".method(:capitalize).to_proc.call.should == "Hello"
+    "hello".method(:upcase).to_proc.call.should == "HELLO"
+  end
+
+  it "works with class methods" do
+    class Lender
+      def self.abc
+        self
+      end
+      def self.xyz
+        abc
+      end
+    end
+
+    module Namespace
+      class Borrower
+        class << self
+          define_method(:xyz, &::Lender.method(:xyz))
+        end
+      end
+    end
+
+    Namespace::Borrower.xyz.should == Lender
+  end
+end

data/spec/opal/core/module/alias_method_spec.rb

@@ -0,0 +1,28 @@
+class AliasMethodSpec
+  module M
+    def something
+      3.142
+    end
+
+    alias_method :something_else, :something
+  end
+
+  include M
+
+  def foo; 'foo'; end
+  alias_method :bar, :foo
+end
+
+describe "Module#alias_method" do
+  it "makes a copy of the method" do
+    AliasMethodSpec.new.bar.should == 'foo'
+  end
+
+  describe "inside a module" do
+    it "defined methods that get donated to a class when included" do
+      obj = AliasMethodSpec.new
+      obj.something.should == 3.142
+      obj.something_else.should == 3.142
+    end
+  end
+end

data/spec/opal/core/module/ancestors_spec.rb

@@ -0,0 +1,11 @@
+module ModuleAncestorsSpec
+  class A; end
+  class B < A; end
+end
+
+describe "Module#ancestors" do
+  it "returns a list of modules in self (including self)" do
+    ModuleAncestorsSpec::B.ancestors.include?(ModuleAncestorsSpec::B).should == true
+    ModuleAncestorsSpec::B.ancestors.include?(ModuleAncestorsSpec::A).should == true
+  end
+end

data/spec/opal/core/module/append_features_spec.rb

@@ -0,0 +1,14 @@
+module AppendFeaturesSpec
+  class Klass; end
+
+  def self.append_features(mod)
+    ScratchPad.record mod
+  end
+end
+
+describe "Module#append_features" do
+  it "gets called when self is included in another module/class" do
+    AppendFeaturesSpec::Klass.include AppendFeaturesSpec
+    ScratchPad.recorded.should == AppendFeaturesSpec::Klass
+  end
+end

data/spec/opal/core/module/attr_accessor_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module AttrAccessorSpec
+  module M
+    attr_accessor :foo
+  end
+
+  class C
+    include M
+  end
+end
+
+describe "Module#attr_accessor" do
+  it "can be passed a splat of arguments" do
+    eval "class OpalAttrAccessorSpec; attr_accessor *%w{foo bar baz}; end"
+    OpalAttrAccessorSpec.new.foo.should be_nil
+  end
+
+  describe "inside a module" do
+    it "defines methods that get donated to a class when included" do
+      obj = AttrAccessorSpec::C.new
+      obj.foo = 100
+      obj.foo.should == 100
+    end
+  end
+end

data/spec/opal/core/module/const_defined_spec.rb

@@ -0,0 +1,85 @@
+require File.expand_path('../../fixtures/constants', __FILE__)
+
+CD_CONST1 = :const1
+
+module ConstDefinedSpecs
+  FOO = 100
+  
+  module Bar
+    BAR = 200
+
+    module Baz
+      BAZ = 300
+    end
+  end
+
+  class Dog
+    LEGS = 4
+  end
+
+  class Bloudhound < Dog
+  end
+end
+
+describe "Module#const_defined?" do
+  it "should consider constants with values that evaluate to false in a JavaScript conditional as defined" do
+    Object.const_defined?("CS_NIL").should be_true
+    Object.const_defined?("CS_ZERO").should be_true
+    Object.const_defined?("CS_BLANK").should be_true
+    Object.const_defined?("CS_FALSE").should be_true
+  end
+
+  it "accepts a String or Symbol name" do
+    Object.const_defined?(:CD_CONST1).should be_true
+    Object.const_defined?("CD_CONST1").should be_true
+  end
+
+  it "should return false if no constant is defined in the search path" do
+    Object.const_defined?(:CS_CONSTX_BAD).should be_false
+  end
+
+  it "raises a NameError if the name does not start with a capital letter" do
+    lambda { ConstantSpecs.const_defined? "name" }.should raise_error(NameError)
+  end
+
+  it "raises a NameError if the name starts with a non-alphabetic character" do
+    lambda { ConstantSpecs.const_defined? "__CONSTX__" }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_defined? "@Name" }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_defined? "!Name" }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_defined? "::Name" }.should raise_error(NameError)
+  end
+
+  it "raises a NameError if the name contains non-word characters" do
+    # underscore (i.e., _) is a valid word character
+    ConstantSpecs.const_defined?("CD_CONST1").should be_true
+    lambda { ConstantSpecs.const_defined? "Name=" }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_defined? "Name?" }.should raise_error(NameError)
+  end
+
+  it "searches parent scopes of classes and modules" do
+    Module.const_defined?(:ConstDefinedSpecs).should be_true
+    ConstDefinedSpecs.const_defined?(:ConstDefinedSpecs).should be_true
+    ConstDefinedSpecs::Bar::Baz.const_defined?(:BAZ).should be_true
+    ConstDefinedSpecs::Bar::Baz.const_defined?(:CD_CONST1).should be_true
+    ConstDefinedSpecs::Bar::Baz.const_defined?(:BAR).should be_false
+    ConstDefinedSpecs::Bar::Baz.const_defined?(:FOO).should be_false
+    ConstDefinedSpecs::Bar::Baz.const_defined?(:Bar).should be_false
+    ConstDefinedSpecs::Bar::Baz.const_defined?(:ConstDefinedSpecs).should be_true
+    ConstDefinedSpecs::Dog.const_defined?(:LEGS).should be_true
+    ConstDefinedSpecs::Dog.const_defined?(:Dog).should be_false
+    ConstDefinedSpecs::Bloudhound.const_defined?(:LEGS).should be_true
+  end
+
+  it "should not search parent scopes of classes and modules if inherit is false" do
+    Module.const_defined?(:ConstDefinedSpecs, false).should be_false
+    ConstDefinedSpecs.const_defined?(:ConstDefinedSpecs, false).should be_false
+    ConstDefinedSpecs::Dog.const_defined?(:LEGS, false).should be_true
+    ConstDefinedSpecs::Dog.const_defined?(:Dog, false).should be_false
+    ConstDefinedSpecs::Bloudhound.const_defined?(:LEGS, false).should be_false
+  end
+
+  it "should search parent scopes of classes and modules for Object regardless of inherit value" do
+    Object.const_defined?(:ConstDefinedSpecs).should be_true
+    Object.const_defined?(:ConstDefinedSpecs, false).should be_true
+  end
+end

data/spec/opal/core/module/const_get_spec.rb

@@ -0,0 +1,85 @@
+require File.expand_path('../../fixtures/constants', __FILE__)
+
+CS_CONST1 = :const1
+
+module ConstGetSpecs
+  FOO = 100
+  
+  module Bar
+    BAR = 200
+
+    module Baz
+      BAZ = 300
+    end
+  end
+
+  class Dog
+    LEGS = 4
+  end
+
+  class Bloudhound < Dog
+  end
+end
+
+describe "Module#const_get" do
+  it "should get constants with values that evaluate to false in a JavaScript conditional" do
+    Object.const_get("CS_NIL").should be_nil
+    Object.const_get("CS_ZERO").should == 0
+    Object.const_get("CS_BLANK").should == ""
+    Object.const_get("CS_FALSE").should == false
+  end
+
+  it "accepts a String or Symbol name" do
+    Object.const_get(:CS_CONST1).should == :const1
+    Object.const_get("CS_CONST1").should == :const1
+  end
+
+  it "raises a NameError if no constant is defined in the search path" do
+    lambda { Object.const_get :CS_CONSTX_BAD }.should raise_error(NameError)
+  end
+
+  it "raises a NameError if the name does not start with a capital letter" do
+    lambda { ConstantSpecs.const_get "name" }.should raise_error(NameError)
+  end
+
+  it "raises a NameError if the name starts with a non-alphabetic character" do
+    lambda { ConstantSpecs.const_get "__CONSTX__" }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_get "@Name" }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_get "!Name" }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_get "::Name" }.should raise_error(NameError)
+  end
+
+  it "raises a NameError if the name contains non-word characters" do
+    # underscore (i.e., _) is a valid word character
+    ConstantSpecs.const_get("CS_CONST1").should == :const1
+    lambda { ConstantSpecs.const_get "Name=" }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_get "Name?" }.should raise_error(NameError)
+  end
+
+  it "searches parent scopes of classes and modules" do
+    Module.const_get(:ConstGetSpecs).should == ConstGetSpecs
+    ConstGetSpecs.const_get(:ConstGetSpecs).should == ConstGetSpecs
+    ConstGetSpecs::Bar::Baz.const_get(:BAZ).should == 300
+    ConstGetSpecs::Bar::Baz.const_get(:CS_CONST1).should == :const1
+    lambda { ConstGetSpecs::Bar::Baz.const_get(:BAR) }.should raise_error(NameError)
+    lambda { ConstGetSpecs::Bar::Baz.const_get(:FOO) }.should raise_error(NameError)
+    lambda { ConstGetSpecs::Bar::Baz.const_get(:Bar) }.should raise_error(NameError)
+    ConstGetSpecs::Bar::Baz.const_get(:ConstGetSpecs).should == ConstGetSpecs
+    ConstGetSpecs::Dog.const_get(:LEGS).should == 4
+    lambda { ConstGetSpecs::Dog.const_get(:Dog) }.should raise_error(NameError)
+    ConstGetSpecs::Bloudhound.const_get(:LEGS).should == 4
+  end
+
+  it "should not search parent scopes of classes and modules if inherit is false" do
+    lambda { Module.const_get(:ConstGetSpecs, false) }.should raise_error(NameError)
+    lambda { ConstGetSpecs.const_get(:ConstGetSpecs, false) }.should raise_error(NameError)
+    ConstGetSpecs::Dog.const_get(:LEGS, false).should == 4
+    lambda { ConstGetSpecs::Dog.const_get(:Dog, false) }.should raise_error(NameError)
+    lambda { ConstGetSpecs::Bloudhound.const_get(:LEGS, false) }.should raise_error(NameError)
+  end
+
+  it "should search parent scopes of classes and modules for Object regardless of inherit value" do
+    Object.const_get(:ConstGetSpecs).should == ConstGetSpecs
+    Object.const_get(:ConstGetSpecs, false).should == ConstGetSpecs
+  end
+end

data/spec/opal/core/module/const_missing_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../fixtures/constants', __FILE__)
+
+describe "Module#const_missing" do
+  it "is called when an undefined constant is referenced via literal form" do
+    ConstantSpecs::ClassA::CS_CONSTX.should == :CS_CONSTX
+  end
+
+  it "is called when an undefined constant is referenced via #const_get" do
+    ConstantSpecs::ClassA.const_get(:CS_CONSTX).should == :CS_CONSTX
+  end
+
+  it "raises NameError and includes the name of the value that wasn't found" do
+    lambda {
+      ConstantSpecs.const_missing("HelloMissing")
+    }.should raise_error(NameError, /ConstantSpecs::HelloMissing/)
+  end
+end

data/spec/opal/core/module/const_set_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../../fixtures/constants', __FILE__)
+
+module ConstantSpecs
+end
+
+describe "Module#const_set" do
+  it "sets the constant specified by a String or Symbol to the given value" do
+    ConstantSpecs.const_set :CS_CONST401, :const401
+    ConstantSpecs::CS_CONST401.should == :const401
+
+    ConstantSpecs.const_set "CS_CONST402", :const402
+    ConstantSpecs.const_get(:CS_CONST402).should == :const402
+  end
+
+  it "returns the value set" do
+    ConstantSpecs.const_set(:CS_CONST403, :const403).should == :const403
+  end
+
+  # PENDING: needs proper parser implementation
+  #
+  # it "sets the name of an anonymous module" do
+  #   m = Module.new
+  #   ConstantSpecs.const_set(:CS_CONST1000, m)
+  #   m.name.should == "ConstantSpecs::CS_CONST1000"
+  # end
+
+  it "raises a NameError if the name does not start with a capital letter" do
+    lambda { ConstantSpecs.const_set "name", 1 }.should raise_error(NameError)
+  end
+
+  it "raises a NameError if the name starts with a non-alphabetic character" do
+    lambda { ConstantSpecs.const_set "__CONSTX__", 1 }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_set "@Name", 1 }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_set "!Name", 1 }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_set "::Name", 1 }.should raise_error(NameError)
+  end
+
+  it "raises a NameError if the name contains non-word characters" do
+    # underscore (i.e., _) is a valid word character
+    ConstantSpecs.const_set("CS_CONST404", :const404).should == :const404
+    lambda { ConstantSpecs.const_set "Name=", 1 }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_set "Name?", 1 }.should raise_error(NameError)
+  end
+
+  # PENDING: should_receive isn't available on opal-spec
+  #
+  # it "calls #to_str to convert the given name to a String" do
+  #
+  #   name = mock("CS_CONST405")
+  #   name.should_receive(:to_str).and_return("CS_CONST405")
+  #   ConstantSpecs.const_set(name, :const405).should == :const405
+  #   ConstantSpecs::CS_CONST405.should == :const405
+  # end
+
+  # PENDING: should_receive isn't available on opal-spec
+  #
+  # it "raises a TypeError if conversion to a String by calling #to_str fails" do
+  #   name = mock('123')
+  #   lambda { ConstantSpecs.const_set name, 1 }.should raise_error(TypeError)
+  #
+  #   name.should_receive(:to_str).and_return(123)
+  #   lambda { ConstantSpecs.const_set name, 1 }.should raise_error(TypeError)
+  # end
+end

data/spec/opal/core/module/constants_spec.rb

@@ -0,0 +1,49 @@
+module ConstantsSpecsModule
+  MOD_CONST1 = "1"
+  MOD_CONST2 = "2"
+  MOD_CONST3 = "3"
+
+  module Foo
+    FOO = "foo"
+  end
+end
+
+class ConstantsSpecsClass
+  CLASS_CONST1 = "1"
+  CLASS_CONST2 = "2"
+  CLASS_CONST3 = "3"
+end
+
+class SubConstantsSpecsClass < ConstantsSpecsClass
+  CLASS_CONST4 = "4"
+end
+
+describe "Module#constants" do
+  it "should return constants in global scope when called from Module or Class" do
+    result = Module.constants
+    result.should include("Module", "Object", "TrueClass", "FalseClass", "RUBY_ENGINE")
+    result2 = Class.constants
+    result.should == result2
+  end
+
+  it "should only return constants and child modules defined directly on module" do
+    result = ConstantsSpecsModule.constants
+    result.size.should == 4
+    result.should include("MOD_CONST1", "MOD_CONST2", "MOD_CONST3", "Foo")
+    result = ConstantsSpecsModule::Foo.constants
+    result.size.should == 1
+    result.should include("FOO")
+  end
+
+  it "should only return constants defined directly on class" do
+    result = ConstantsSpecsClass.constants
+    result.size.should == 3
+    result.should include("CLASS_CONST1", "CLASS_CONST2", "CLASS_CONST3")
+  end
+
+  it "should include constants inherited from superclass" do
+    result = SubConstantsSpecsClass.constants
+    result.size.should == 4
+    result.should include("CLASS_CONST4", "CLASS_CONST1", "CLASS_CONST2", "CLASS_CONST3")
+  end
+end