metaruby 1.0.0.rc1

data/test/test_dsls.rb

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

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

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

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: metaruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
+platform: ruby
+authors:
+- Sylvain Joyeux
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: utilrb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.4
+- !ruby/object:Gem::Dependency
+  name: hoe-yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: |-
+  This page will describe the various functionality that metaruby provides to help
+  modelling in Ruby.
+
+  This page will reuse one of the most overused example of modelling: a car and
+  colors.
+
+  ## Models
+
+  Using MetaRuby, models can either be represented by Ruby classes or by Ruby
+  modules. You use the first one when you want to model something from which an
+  object can be created, in our example: a car. You use the second for things that
+  cannot be instanciated, but can be used as attributes of another object, in our
+  example: a color.
+email:
+- sylvain.joyeux@m4x.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- History.txt
+- Manifest.txt
+- README.md
+files:
+- ".gemtest"
+- History.txt
+- Manifest.txt
+- README.md
+- Rakefile
+- lib/metaruby.rb
+- lib/metaruby/class.rb
+- lib/metaruby/dsls.rb
+- lib/metaruby/dsls/doc.rb
+- lib/metaruby/dsls/find_through_method_missing.rb
+- lib/metaruby/gui.rb
+- lib/metaruby/gui/exception_view.rb
+- lib/metaruby/gui/html.rb
+- lib/metaruby/gui/html/button.rb
+- lib/metaruby/gui/html/collection.rb
+- lib/metaruby/gui/html/exception_view.css
+- lib/metaruby/gui/html/jquery.min.js
+- lib/metaruby/gui/html/jquery.selectfilter.js
+- lib/metaruby/gui/html/jquery.tagcloud.min.js
+- lib/metaruby/gui/html/jquery.tinysort.min.js
+- lib/metaruby/gui/html/list.rhtml
+- lib/metaruby/gui/html/page.css
+- lib/metaruby/gui/html/page.rb
+- lib/metaruby/gui/html/page.rhtml
+- lib/metaruby/gui/html/page_body.rhtml
+- lib/metaruby/gui/html/rock-website.css
+- lib/metaruby/gui/model_browser.rb
+- lib/metaruby/gui/model_selector.rb
+- lib/metaruby/gui/rendering_manager.rb
+- lib/metaruby/gui/ruby_constants_item_model.rb
+- lib/metaruby/inherited_attribute.rb
+- lib/metaruby/module.rb
+- lib/metaruby/registration.rb
+- lib/metaruby/test.rb
+- manifest.xml
+- test/suite.rb
+- test/test_attributes.rb
+- test/test_class.rb
+- test/test_dsls.rb
+- test/test_module.rb
+- test/test_registration.rb
+homepage: https://gitorious.org/rock-toolchain/metaruby
+licenses:
+- LGPLv3+
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--title"
+- TestMetaruby Documentation
+- "--quiet"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Modelling using the Ruby language as a metamodel
+test_files: []