diff options
Diffstat (limited to 'spec/ruby/core/module/shared')
| -rw-r--r-- | spec/ruby/core/module/shared/attr_added.rb | 34 | ||||
| -rw-r--r-- | spec/ruby/core/module/shared/class_eval.rb | 115 | ||||
| -rw-r--r-- | spec/ruby/core/module/shared/class_exec.rb | 29 | ||||
| -rw-r--r-- | spec/ruby/core/module/shared/set_visibility.rb | 75 |
4 files changed, 96 insertions, 157 deletions
diff --git a/spec/ruby/core/module/shared/attr_added.rb b/spec/ruby/core/module/shared/attr_added.rb new file mode 100644 index 0000000000..ce832cdcff --- /dev/null +++ b/spec/ruby/core/module/shared/attr_added.rb @@ -0,0 +1,34 @@ +describe :module_attr_added, shared: true do + it "calls method_added for normal classes" do + ScratchPad.record [] + + cls = Class.new do + class << self + def method_added(name) + ScratchPad.recorded << name + end + end + end + + cls.send(@method, :foo) + + ScratchPad.recorded.each {|name| name.to_s.should =~ /foo[=]?/} + end + + it "calls singleton_method_added for singleton classes" do + ScratchPad.record [] + cls = Class.new do + class << self + def singleton_method_added(name) + # called for this def so ignore it + return if name == :singleton_method_added + ScratchPad.recorded << name + end + end + end + + cls.singleton_class.send(@method, :foo) + + ScratchPad.recorded.each {|name| name.to_s.should =~ /foo[=]?/} + end +end diff --git a/spec/ruby/core/module/shared/class_eval.rb b/spec/ruby/core/module/shared/class_eval.rb deleted file mode 100644 index 6bb9668fee..0000000000 --- a/spec/ruby/core/module/shared/class_eval.rb +++ /dev/null @@ -1,115 +0,0 @@ -describe :module_class_eval, shared: true do - # TODO: This should probably be replaced with a "should behave like" that uses - # the many scoping/binding specs from kernel/eval_spec, since most of those - # behaviors are the same for instance_eval. See also module_eval/class_eval. - - it "evaluates a given string in the context of self" do - ModuleSpecs.send(@method, "self").should == ModuleSpecs - ModuleSpecs.send(@method, "1 + 1").should == 2 - end - - it "does not add defined methods to other classes" do - FalseClass.send(@method) do - def foo - 'foo' - end - end - lambda {42.foo}.should raise_error(NoMethodError) - end - - it "resolves constants in the caller scope" do - ModuleSpecs::ClassEvalTest.get_constant_from_scope.should == ModuleSpecs::Lookup - end - - it "resolves constants in the caller scope ignoring send" do - ModuleSpecs::ClassEvalTest.get_constant_from_scope_with_send(@method).should == ModuleSpecs::Lookup - end - - it "resolves constants in the receiver's scope" do - ModuleSpecs.send(@method, "Lookup").should == ModuleSpecs::Lookup - ModuleSpecs.send(@method, "Lookup::LOOKIE").should == ModuleSpecs::Lookup::LOOKIE - end - - it "defines constants in the receiver's scope" do - ModuleSpecs.send(@method, "module NewEvaluatedModule;end") - ModuleSpecs.const_defined?(:NewEvaluatedModule, false).should == true - end - - it "evaluates a given block in the context of self" do - ModuleSpecs.send(@method) { self }.should == ModuleSpecs - ModuleSpecs.send(@method) { 1 + 1 }.should == 2 - end - - it "passes the module as the first argument of the block" do - given = nil - ModuleSpecs.send(@method) do |block_parameter| - given = block_parameter - end - given.should equal ModuleSpecs - end - - it "uses the optional filename and lineno parameters for error messages" do - ModuleSpecs.send(@method, "[__FILE__, __LINE__]", "test", 102).should == ["test", 102] - end - - it "converts a non-string filename to a string using to_str" do - (file = mock(__FILE__)).should_receive(:to_str).and_return(__FILE__) - ModuleSpecs.send(@method, "1+1", file) - end - - it "raises a TypeError when the given filename can't be converted to string using to_str" do - (file = mock('123')).should_receive(:to_str).and_return(123) - lambda { ModuleSpecs.send(@method, "1+1", file) }.should raise_error(TypeError) - end - - it "converts non string eval-string to string using to_str" do - (o = mock('1 + 1')).should_receive(:to_str).and_return("1 + 1") - ModuleSpecs.send(@method, o).should == 2 - end - - it "raises a TypeError when the given eval-string can't be converted to string using to_str" do - o = mock('x') - lambda { ModuleSpecs.send(@method, o) }.should raise_error(TypeError) - - (o = mock('123')).should_receive(:to_str).and_return(123) - lambda { ModuleSpecs.send(@method, o) }.should raise_error(TypeError) - end - - it "raises an ArgumentError when no arguments and no block are given" do - lambda { ModuleSpecs.send(@method) }.should raise_error(ArgumentError) - end - - it "raises an ArgumentError when more than 3 arguments are given" do - lambda { - ModuleSpecs.send(@method, "1 + 1", "some file", 0, "bogus") - }.should raise_error(ArgumentError) - end - - it "raises an ArgumentError when a block and normal arguments are given" do - lambda { - ModuleSpecs.send(@method, "1 + 1") { 1 + 1 } - }.should raise_error(ArgumentError) - end - - # This case was found because Rubinius was caching the compiled - # version of the string and not duping the methods within the - # eval, causing the method addition to change the static scope - # of the shared CompiledCode. - it "adds methods respecting the lexical constant scope" do - code = "def self.attribute; C; end" - - a = Class.new do - self::C = "A" - end - - b = Class.new do - self::C = "B" - end - - a.send @method, code - b.send @method, code - - a.attribute.should == "A" - b.attribute.should == "B" - end -end diff --git a/spec/ruby/core/module/shared/class_exec.rb b/spec/ruby/core/module/shared/class_exec.rb deleted file mode 100644 index c5c18b0a34..0000000000 --- a/spec/ruby/core/module/shared/class_exec.rb +++ /dev/null @@ -1,29 +0,0 @@ -describe :module_class_exec, shared: true do - it "does not add defined methods to other classes" do - FalseClass.send(@method) do - def foo - 'foo' - end - end - lambda {42.foo}.should raise_error(NoMethodError) - end - - it "defines method in the receiver's scope" do - ModuleSpecs::Subclass.send(@method) { def foo; end } - ModuleSpecs::Subclass.new.respond_to?(:foo).should == true - end - - it "evaluates a given block in the context of self" do - ModuleSpecs::Subclass.send(@method) { self }.should == ModuleSpecs::Subclass - ModuleSpecs::Subclass.new.send(@method) { 1 + 1 }.should == 2 - end - - it "raises a LocalJumpError when no block is given" do - lambda { ModuleSpecs::Subclass.send(@method) }.should raise_error(LocalJumpError) - end - - it "passes arguments to the block" do - a = ModuleSpecs::Subclass - a.send(@method, 1) { |b| b }.should equal(1) - end -end diff --git a/spec/ruby/core/module/shared/set_visibility.rb b/spec/ruby/core/module/shared/set_visibility.rb index c39d59e05d..38cc2ad260 100644 --- a/spec/ruby/core/module/shared/set_visibility.rb +++ b/spec/ruby/core/module/shared/set_visibility.rb @@ -2,7 +2,56 @@ describe :set_visibility, shared: true do it "is a private method" do - Module.should have_private_instance_method(@method, false) + Module.private_instance_methods(false).should.include?(@method) + end + + describe "with argument" do + describe "one or more arguments" do + it "sets visibility of given method names" do + visibility = @method + old_visibility = [:protected, :private].find {|vis| vis != visibility } + + mod = Module.new { + send old_visibility + def test1() end + def test2() end + send visibility, :test1, :test2 + } + mod.send(:"#{visibility}_instance_methods", false).should.include?(:test1) + mod.send(:"#{visibility}_instance_methods", false).should.include?(:test2) + end + end + + describe "array as a single argument" do + it "sets visibility of given method names" do + visibility = @method + old_visibility = [:protected, :private].find {|vis| vis != visibility } + + mod = Module.new { + send old_visibility + def test1() end + def test2() end + send visibility, [:test1, :test2] + } + mod.send(:"#{visibility}_instance_methods", false).should.include?(:test1) + mod.send(:"#{visibility}_instance_methods", false).should.include?(:test2) + end + end + + it "does not clone method from the ancestor when setting to the same visibility in a child" do + visibility = @method + parent = Module.new { + def test_method; end + send(visibility, :test_method) + } + + child = Module.new { + include parent + send(visibility, :test_method) + } + + child.send(:"#{visibility}_instance_methods", false).should_not.include?(:test_method) + end end describe "without arguments" do @@ -15,8 +64,8 @@ describe :set_visibility, shared: true do def test2() end } - mod.should send(:"have_#{@method}_instance_method", :test1, false) - mod.should send(:"have_#{@method}_instance_method", :test2, false) + mod.send(:"#{@method}_instance_methods", false).should.include?(:test1) + mod.send(:"#{@method}_instance_methods", false).should.include?(:test2) end it "stops setting visibility if the body encounters other visibility setters without arguments" do @@ -29,7 +78,7 @@ describe :set_visibility, shared: true do def test1() end } - mod.should send(:"have_#{new_visibility}_instance_method", :test1, false) + mod.send(:"#{new_visibility}_instance_methods", false).should.include?(:test1) end it "continues setting visibility if the body encounters other visibility setters with arguments" do @@ -41,7 +90,7 @@ describe :set_visibility, shared: true do def test2() end } - mod.should send(:"have_#{@method}_instance_method", :test2, false) + mod.send(:"#{@method}_instance_methods", false).should.include?(:test2) end it "does not affect module_evaled method definitions when itself is outside the eval" do @@ -53,8 +102,8 @@ describe :set_visibility, shared: true do module_eval " def test2() end " } - mod.should have_public_instance_method(:test1, false) - mod.should have_public_instance_method(:test2, false) + mod.public_instance_methods(false).should.include?(:test1) + mod.public_instance_methods(false).should.include?(:test2) end it "does not affect outside method definitions when itself is inside a module_eval" do @@ -65,7 +114,7 @@ describe :set_visibility, shared: true do def test1() end } - mod.should have_public_instance_method(:test1, false) + mod.public_instance_methods(false).should.include?(:test1) end it "affects normally if itself and method definitions are inside a module_eval" do @@ -78,7 +127,7 @@ describe :set_visibility, shared: true do } } - mod.should send(:"have_#{@method}_instance_method", :test1, false) + mod.send(:"#{@method}_instance_methods", false).should.include?(:test1) end it "does not affect method definitions when itself is inside an eval and method definitions are outside" do @@ -91,7 +140,7 @@ describe :set_visibility, shared: true do def test1() end } - mod.should send(:"have_#{initialized_visibility}_instance_method", :test1, false) + mod.send(:"#{initialized_visibility}_instance_methods", false).should.include?(:test1) end it "affects evaled method definitions when itself is outside the eval" do @@ -102,7 +151,7 @@ describe :set_visibility, shared: true do eval "def test1() end" } - mod.should send(:"have_#{@method}_instance_method", :test1, false) + mod.send(:"#{@method}_instance_methods", false).should.include?(:test1) end it "affects normally if itself and following method definitions are inside a eval" do @@ -115,7 +164,7 @@ describe :set_visibility, shared: true do CODE } - mod.should send(:"have_#{@method}_instance_method", :test1, false) + mod.send(:"#{@method}_instance_methods", false).should.include?(:test1) end describe "within a closure" do @@ -128,7 +177,7 @@ describe :set_visibility, shared: true do def test1() end } - mod.should send(:"have_#{@method}_instance_method", :test1, false) + mod.send(:"#{@method}_instance_methods", false).should.include?(:test1) end end end |