metaruby 1.0.0.rc1 → 1.0.0.rc2

data/test/test_class.rb

@@ -1,68 +0,0 @@
-require 'metaruby/test'
-
-class Base
-    extend MetaRuby::ModelAsClass
-end
-
-module DefinitionContext
-    class Klass < Base; end
-end
-
-module PermanentDefinitionContext
-    def self.permanent_model?; true end
-    class Klass < Base; end
-end
-
-module NonPermanentDefinitionContext
-    def self.permanent_model?; false end
-    class Klass < Base; end
-end
-
-describe MetaRuby::ModelAsClass do
-    include MetaRuby::SelfTest
-
-    before do
-        # Code that is run before each test
-    end
-    after do
-        # Code that is run after each test
-    end
-
-    describe "Using modules as metamodel" do
-        it "should apply the Attribute module on sub-metamodels for classes" do
-            mod = Module.new { include MetaRuby::ModelAsClass }
-            sub = Module.new { include mod }
-            assert mod.respond_to?(:inherited_attribute)
-            assert sub.respond_to?(:inherited_attribute)
-        end
-    end
-
-    describe "#new_submodel" do
-        it "should call setup_submodel only once" do
-            mod = Module.new { include MetaRuby::ModelAsClass }
-            klass = Class.new { extend mod }
-            flexmock(klass).should_receive(:setup_submodel).once
-            klass.new_submodel
-        end
-        it "should set permanent_model to false on the class" do
-        end
-    end
-
-    describe "creating subclasses" do
-        it "should set permanent_model to false on the class if the enclosing context is not properly registered as a constant" do
-            definition_context = Module.new do
-                Klass = Class.new(Base)
-            end
-            assert !definition_context.const_get(:Klass).permanent_model?
-        end
-        it "should set permanent_model to true on the class if the enclosing context is properly registered as a constant but is not responding to permanent_model?" do
-            assert DefinitionContext::Klass.permanent_model?
-        end
-        it "should set permanent_model to true on the class if the enclosing context is permanent" do
-            assert PermanentDefinitionContext::Klass.permanent_model?
-        end
-        it "should set permanent_model to false on the class if the enclosing context is not permanent" do
-            assert !NonPermanentDefinitionContext::Klass.permanent_model?
-        end
-    end
-end

data/test/test_dsls.rb

@@ -1,49 +0,0 @@
-require 'metaruby/test'
-require 'metaruby/dsls/find_through_method_missing'
-
-describe MetaRuby::DSLs do
-    include MetaRuby::SelfTest
-
-    describe "#find_through_method_missing" do
-        it "should call the corresponding find method when matching" do
-            obj = flexmock
-            obj.should_receive(:find_obj).with("test").once.and_return(found = flexmock)
-            assert_equal found, MetaRuby::DSLs.find_through_method_missing(obj, :test_obj, [], "obj")
-        end
-        it "should allow specifying the find method name" do
-            obj = flexmock
-            obj.should_receive(:find_obj).with("test").once.and_return(found = flexmock)
-            assert_equal found, MetaRuby::DSLs.find_through_method_missing(obj, :test_bla, [], "bla" => 'find_obj')
-        end
-        it "should raise NoMethodError if the requested object is not found" do
-            obj = flexmock
-            obj.should_receive(:find_obj).with("test").once.and_return(nil)
-            assert_raises(NoMethodError) do
-                MetaRuby::DSLs.find_through_method_missing(obj, :test_obj, [], "obj")
-            end
-        end
-        it "should raise ArgumentError if some arguments are given regardless of whether the object exists" do
-            obj = flexmock
-            obj.should_receive(:find_obj).never
-            assert_raises(ArgumentError) do
-                MetaRuby::DSLs.find_through_method_missing(obj, :test_obj, [10], "obj")
-            end
-        end
-        it "should ignore non-matching methods and return nil" do
-            obj = flexmock
-            assert !MetaRuby::DSLs.find_through_method_missing(obj, :test_bla, [10], "obj")
-        end
-        it "should raise if the missing method is one of the expected find methods" do
-            # NOTE: do not use flexmock here, as specifying 'never' on a call
-            # spec makes flexmock raise a NoMethodError !!!
-            called = false
-            obj = Class.new do
-                define_method(:find_obj) { |name| called = true }
-            end.new
-            assert_raises(NoMethodError) do
-                MetaRuby::DSLs.find_through_method_missing(obj, :find_obj, [], "obj")
-            end
-            assert !called
-        end
-    end
-end

data/test/test_module.rb

@@ -1,105 +0,0 @@
-require 'metaruby/test'
-
-describe MetaRuby::ModelAsModule do
-    include MetaRuby::SelfTest
-
-    attr_reader :root_m
-    before do
-        @root_m = Module.new { extend MetaRuby::ModelAsModule }
-    end
-
-    describe "#provides" do
-        it "sets the supermodel to the provided model if it is root" do
-            root_m.root = true
-            submodel = Module.new { extend MetaRuby::ModelAsModule }
-            submodel.provides root_m
-            assert_equal root_m, submodel.supermodel
-        end
-        it "sets root_model to the provided model's supermodel if the provided model is not root itself" do
-            flexmock(root_m).should_receive(:supermodel).once.
-                and_return(root = flexmock)
-            submodel = Module.new { extend MetaRuby::ModelAsModule }
-            root.should_receive(:register_submodel).with(submodel).once
-            submodel.provides root_m
-            assert_equal root, submodel.supermodel
-        end
-    end
-
-    describe "Using modules as metamodel" do
-        it "should apply the Attribute module on sub-metamodels for modules" do
-            mod = Module.new { include MetaRuby::ModelAsModule }
-            sub = Module.new { include mod }
-            assert mod.respond_to?(:inherited_attribute)
-            assert sub.respond_to?(:inherited_attribute)
-        end
-    end
-
-    describe "#new_submodel" do
-        it "should mark the model as non-permanent" do
-            root = Module.new do
-                extend MetaRuby::ModelAsModule
-                self.root = true
-            end
-            sub = root.new_submodel
-            assert !sub.new_submodel.permanent_model?
-        end
-    end
-
-    describe "#create_and_register_submodel" do
-        attr_reader :definition_context, :base_m
-        before do
-            @definition_context = Module.new
-            @base_m = Module.new do
-                extend MetaRuby::ModelAsModule
-                def self.root?; true end
-            end
-        end
-
-        it "should set permanent_model to true if the enclosing module is a Ruby module that is accessible by name" do
-            flexmock(MetaRuby::Registration).should_receive(:accessible_by_name?).with(definition_context).and_return(true)
-            result = MetaRuby::ModelAsModule.create_and_register_submodel(definition_context, 'Test', base_m)
-            assert result.permanent_model?
-        end
-        it "should set permanent_model to false if the enclosing module is a Ruby module that is not accessible by name" do
-            flexmock(definition_context).should_receive(:accessible_by_name?).and_return(false)
-            result = MetaRuby::ModelAsModule.create_and_register_submodel(definition_context, 'Test', base_m)
-            assert !result.permanent_model?
-        end
-        it "should set permanent_model to true if the enclosing module is permanent" do
-            flexmock(definition_context).should_receive(:permanent_model?).and_return(true)
-            result = MetaRuby::ModelAsModule.create_and_register_submodel(definition_context, 'Test', base_m)
-            assert result.permanent_model?
-        end
-        it "should set permanent_model to false if the enclosing module is non-permanent" do
-            flexmock(definition_context).should_receive(:permanent_model?).and_return(false)
-            result = MetaRuby::ModelAsModule.create_and_register_submodel(definition_context, 'Test', base_m)
-            assert !result.permanent_model?
-        end
-    end
-
-    describe "#clear_model" do
-        attr_reader :root_m, :model_m
-        before do
-            @root_m = Module.new do
-                extend MetaRuby::ModelAsModule
-                self.root = true
-                self.permanent_model = true
-            end
-            @model_m = root_m.new_submodel
-            model_m.permanent_model = true
-        end
-
-        it "deregisters the module regardless of the permanent_model flag" do
-            flexmock(root_m).should_receive(:deregister_submodels).with([model_m]).once
-            model_m.permanent_model = true
-            model_m.clear_model
-        end
-        it "clears its parent model set" do
-            flexmock(root_m).should_receive(:deregister_submodels).with([model_m]).once
-            model_m.permanent_model = true
-            model_m.clear_model
-            assert model_m.parent_models.empty?
-        end
-    end
-end
-

data/test/test_registration.rb

@@ -1,182 +0,0 @@
-require 'metaruby/test'
-
-class Constant
-    extend MetaRuby::Registration
-end
-module Mod
-    class Constant
-        extend MetaRuby::Registration
-    end
-end
-
-describe MetaRuby::Registration do
-    include MetaRuby::SelfTest
-
-    class ModelStub
-        extend MetaRuby::Registration
-    end
-
-    def model_stub(parent_model = nil)
-        result = Class.new(ModelStub)
-        result.permanent_model = false
-        flexmock(result).should_receive(:supermodel).and_return(parent_model).by_default
-        if parent_model
-            parent_model.register_submodel(result)
-        end
-        result
-    end
-
-    describe "#register_submodel" do
-        attr_reader :base_model
-        before do
-            @base_model = model_stub
-        end
-
-        it "registers the model on the receiver" do
-            sub_model = Class.new(ModelStub)
-            base_model.register_submodel(sub_model)
-            assert(base_model.each_submodel.find { |m| m == sub_model })
-        end
-        it "registers the model on the receiver's parent model" do
-            parent_model = Class.new(ModelStub)
-            sub_model = Class.new(ModelStub)
-            flexmock(base_model).should_receive(:supermodel).and_return(parent_model)
-            flexmock(parent_model).should_receive(:register_submodel).with(sub_model).once
-            base_model.register_submodel(sub_model)
-        end
-    end
-
-    describe "#deregister_submodel" do
-        attr_reader :base_model, :sub_model
-        before do
-            @base_model = model_stub
-            @sub_model = model_stub(base_model)
-        end
-
-        it "deregisters the models on the receiver" do
-            flexmock(base_model).should_receive(:supermodel).and_return(nil).once
-            base_model.deregister_submodels([sub_model])
-            assert(base_model.each_submodel.to_a.empty?)
-        end
-        it "deregisters the models on the receiver's parent model" do
-            parent_model = flexmock
-            flexmock(base_model).should_receive(:supermodel).and_return(parent_model)
-            flexmock(parent_model).should_receive(:deregister_submodels).with([sub_model]).once
-            base_model.deregister_submodels([sub_model])
-        end
-        it "always calls the parent model's deregister method" do
-            parent_model = flexmock
-            flexmock(base_model).should_receive(:supermodel).and_return(parent_model)
-            flexmock(base_model).should_receive(:deregister_submodels).with([sub_model]).pass_thru
-            flexmock(parent_model).should_receive(:deregister_submodels).with([sub_model]).once
-            base_model.deregister_submodels([sub_model])
-        end
-        it "returns true if a model got deregistered" do
-            flexmock(base_model).should_receive(:supermodel).and_return(nil).once
-            assert base_model.deregister_submodels([sub_model])
-        end
-        it "returns false if no models got deregistered" do
-            assert !base_model.deregister_submodels([flexmock])
-        end
-    end
-
-    describe "#clear_models" do
-        attr_reader :base_model, :sub_model
-        before do
-            @base_model = model_stub
-            @sub_model = model_stub(base_model)
-        end
-        it "deregisters the non-permanent models, and calls #clear_submodels on them" do
-            base_model.should_receive(:deregister_submodels).with([sub_model]).once.pass_thru
-            sub_model.should_receive(:clear_submodels).once
-            base_model.clear_submodels
-        end
-        it "does not deregister the permanent models, but still calls #clear_submodels on them" do
-            base_model.should_receive(:deregister_submodels).with([]).never
-            sub_model.should_receive(:permanent_model?).and_return(true).once
-            sub_model.should_receive(:clear_submodels).once
-            base_model.clear_submodels
-        end
-        it "calls #clear_submodels on non-permanent submodels" do
-            flexmock(sub_model).should_receive(:permanent_model?).and_return(false).once
-            flexmock(sub_model).should_receive(:clear_submodels).once
-            base_model.clear_submodels
-        end
-        it "calls #clear_submodels on permanent submodels" do
-            flexmock(sub_model).should_receive(:permanent_model?).and_return(true).once
-            flexmock(sub_model).should_receive(:clear_submodels).once
-            # Create another submodel so that there is something to clear
-            model_stub(base_model)
-            base_model.clear_submodels
-        end
-        it "does not deregister the permanent models" do
-            flexmock(sub_model).should_receive(:permanent_model?).and_return(true).once
-            flexmock(base_model).should_receive(:deregister_submodels).with([]).never
-            base_model.clear_submodels
-        end
-        it "should deregister before it clears" do
-            flexmock(sub_model).should_receive(:permanent_model?).and_return(false).once
-            flexmock(base_model).should_receive(:deregister_submodels).once.ordered.pass_thru
-            flexmock(sub_model).should_receive(:clear_submodels).once.ordered
-            base_model.clear_submodels
-        end
-    end
-
-    describe "#accessible_by_name?" do
-        it "should be true for toplevel classes / modules" do
-            assert Constant.accessible_by_name?
-        end
-
-        it "should be true for classes / modules defined in namespaces" do
-            assert Mod::Constant.accessible_by_name?
-        end
-
-        it "should be false for anonymous classes / modules" do
-            klass = Class.new { extend MetaRuby::Registration }
-            assert !klass.accessible_by_name?
-        end
-    end
-
-    describe "#clear_model" do
-        attr_reader :obj, :supermodel
-        before do
-            @obj = Class.new do
-                extend MetaRuby::Registration
-            end
-            @supermodel = flexmock
-            supermodel.should_receive(:deregister_submodels).by_default
-            flexmock(obj).should_receive(:supermodel).and_return(supermodel)
-        end
-
-        it "should deregister itself from its parent models if it is non-permanent and has supermodels" do
-            supermodel.should_receive(:deregister_submodels).once.with([obj])
-            obj.permanent_model = false
-            obj.clear_model
-        end
-
-        it "should deregister itself from the constant hierarchy if non-permanent" do
-            obj.permanent_model = false
-            flexmock(MetaRuby::Registration).should_receive(:accessible_by_name?).once.with(obj).and_return(true)
-            flexmock(MetaRuby::Registration).should_receive(:deregister_constant).once.with(obj)
-            obj.clear_model
-        end
-
-        it "should not touch the receiver's registration if permanent" do
-            obj.permanent_model = true
-            flexmock(MetaRuby::Registration).should_receive(:deregister_constant).never
-            supermodel.should_receive(:deregister_submodels).never
-            obj.clear_model
-        end
-    end
-
-    describe "#deregister_constant" do
-        it "should deregister the object on the enclosing context" do
-            obj = flexmock(:basename => "Name", :spacename => "Test")
-            context = flexmock
-            flexmock(MetaRuby::Registration).should_receive(:constant).with("::Test").and_return(context)
-            context.should_receive(:remove_const).with('Name').once
-            MetaRuby::Registration.deregister_constant(obj)
-        end
-    end
-end
-