metaruby 1.0.0.rc1

data/lib/metaruby/registration.rb

@@ -0,0 +1,157 @@
+require 'facets/module/spacename'
+require 'facets/module/basename'
+require 'facets/kernel/call_stack'
+require 'utilrb/object/attribute'
+require 'utilrb/module/attr_predicate'
+module MetaRuby
+    # Handling of registration of model hierarchies
+    #
+    # It depends on the mixed-in object to provide a #supermodel method that
+    # returns the model that is parent of +self+
+    module Registration
+        # The place where this model got defined in the source code
+        # The tuple is (file,lineno,method), and can be obtained with
+        # facet's #call_stack
+        # @return [Array<(String,Integer,Symbol)>]
+        attr_accessor :definition_location
+
+        # Tells {#clear_submodels} whether this model should be removed from
+        # the model set or not. The default is false (it should be removed)
+        #
+        # @return [Boolean]
+        attr_predicate :permanent_model?, true
+
+        # [Set] the set of models that are children of this one
+        attribute(:submodels) { Set.new }
+
+        # Returns the model that is parent of this one
+        #
+        # The default implementation returns superclass if it is extended by
+        # this Registration module, and nil otherwise
+        def supermodel
+            if superclass.respond_to?(:register_submodel)
+                superclass
+            end
+        end
+
+        # @return [Boolean] true if the definition context (module, class) in
+        #   which self is registered is permanent or not w.r.t. the model
+        #   registration functionality of metaruby
+        def permanent_definition_context?
+            return false if !name
+            definition_context_name = spacename
+            if !definition_context_name.empty?
+                begin
+                    enclosing_context = constant("::#{definition_context_name}")
+                    return !enclosing_context.respond_to?(:permanent_model?) || enclosing_context.permanent_model?
+                rescue NameError
+                    false
+                end
+            else
+                true
+            end
+        end
+
+        # @return [Boolean] true if the given object can be accessed by resolving its
+        #   name as a constant
+        def self.accessible_by_name?(object)
+            return false if !object.respond_to?(:name) || !object.name
+            begin
+                constant("::#{object.name}") == object
+            rescue NameError
+                false
+            end
+        end
+
+        # @return [Boolean] true if this object can be accessed by resolving its
+        #   name as a constant
+        def accessible_by_name?
+            Registration.accessible_by_name?(self)
+        end
+
+        # Call to register a model that is a submodel of +self+
+        def register_submodel(klass)
+            if !klass.definition_location
+                klass.definition_location = call_stack
+            end
+
+            submodels << klass
+            if m = supermodel
+                m.register_submodel(klass)
+            end
+        end
+
+        # Enumerates all models that are submodels of this class
+        def each_submodel
+            return enum_for(:each_submodel) if !block_given?
+            submodels.each do |obj|
+                yield(obj)
+            end
+        end
+
+        def clear_model
+            if !permanent_model?
+                if m = supermodel
+                    m.deregister_submodels([self])
+                end
+                if Registration.accessible_by_name?(self)
+                    Registration.deregister_constant(self)
+                end
+            end
+            clear_submodels
+        end
+        
+        # Removes the constant that stores the given object in the Ruby constant
+        # hierarchy
+        #
+        # It assumes that calling #name on the object returns the place in the
+        # constant hierarchy where it is stored
+        def self.deregister_constant(obj)
+            constant("::#{obj.spacename}").send(:remove_const, obj.basename)
+        end
+
+        # Clears all registered submodels
+        def clear_submodels
+            children = self.submodels.find_all { |m| !m.permanent_model? }
+            if !children.empty?
+                deregister_submodels(children)
+            end
+
+            children.each do |m|
+                # Deregister non-permanent models that are registered in the
+                # constant hierarchy
+                if Registration.accessible_by_name?(m)
+                    Registration.deregister_constant(m)
+                end
+            end
+
+            # This contains the permanent submodels
+            #
+            # We can call #clear_submodels while iterating here as it is a
+            # constraint that all models in #submodels are permanent (and
+            # will therefore not be removed)
+            submodels.each { |m| m.clear_submodels }
+            # And this the non-permanent ones
+            children.each { |m| m.clear_submodels }
+            true
+        end
+
+        # Deregisters a set of submodels on this model and all its
+        # supermodels
+        #
+        # This is usually not called directly. Use #clear_submodels instead
+        #
+        # @param [Set] set the set of submodels to remove
+        def deregister_submodels(set)
+            current_size = submodels.size
+            submodels.subtract(set)
+            if m = supermodel
+                m.deregister_submodels(set)
+            end
+            current_size != submodels.size
+        end
+    end
+end
+
+
+

data/lib/metaruby/test.rb

@@ -0,0 +1,79 @@
+# simplecov must be loaded FIRST. Only the files required after it gets loaded
+# will be profiled !!!
+if ENV['TEST_ENABLE_COVERAGE'] == '1'
+    begin
+        require 'simplecov'
+        SimpleCov.start
+    rescue LoadError
+        require 'metaruby'
+        MetaRuby.warn "coverage is disabled because the 'simplecov' gem cannot be loaded"
+    rescue Exception => e
+        require 'metaruby'
+        MetaRuby.warn "coverage is disabled: #{e.message}"
+    end
+end
+
+require 'metaruby'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'flexmock/test_unit'
+
+if ENV['TEST_ENABLE_PRY'] != '0'
+    begin
+        require 'pry'
+        if ENV['TEST_DEBUG'] == '1'
+            require 'pry-rescue/minitest'
+        end
+    rescue Exception
+        MetaRuby.warn "debugging is disabled because the 'pry' gem cannot be loaded"
+    end
+end
+
+module MetaRuby
+    # This module is the common setup for all tests
+    #
+    # It should be included in the toplevel describe blocks
+    #
+    # @example
+    #   require 'metaruby/test'
+    #   describe MetaRuby do
+    #     include MetaRuby::SelfTest
+    #   end
+    #
+    module SelfTest
+        if defined? FlexMock
+            include FlexMock::ArgumentTypes
+            include FlexMock::MockContainer
+        end
+
+        def setup
+            # Setup code for all the tests
+        end
+
+        def teardown
+            if defined? FlexMock
+                flexmock_teardown
+            end
+            # Teardown code for all the tests
+        end
+    end
+end
+
+# Workaround a problem with flexmock and minitest not being compatible with each
+# other (currently). See github.com/jimweirich/flexmock/issues/15.
+if defined?(FlexMock) && !FlexMock::TestUnitFrameworkAdapter.method_defined?(:assertions)
+    class FlexMock::TestUnitFrameworkAdapter
+        attr_accessor :assertions
+    end
+    FlexMock.framework_adapter.assertions = 0
+end
+
+module Minitest
+    class Spec
+        include MetaRuby::SelfTest
+    end
+    class Test
+        include MetaRuby::SelfTest
+    end
+end
+

data/lib/metaruby.rb

@@ -0,0 +1,17 @@
+require 'utilrb/object/attribute'
+
+require 'metaruby/inherited_attribute'
+require 'metaruby/registration'
+require 'metaruby/module'
+require 'metaruby/class'
+
+# The toplevel namespace for MetaRuby
+#
+# MetaRuby is an implementation of a (very small) modelling toolkit that uses
+# the Ruby type system as its meta-metamodel
+require 'utilrb/logger'
+module MetaRuby
+    LIB_DIR = File.expand_path('metaruby', File.dirname(__FILE__))
+    extend Logger::Root('MetaRuby', Logger::WARN)
+end
+

data/manifest.xml

@@ -0,0 +1,12 @@
+<package>
+  <description brief="Modelling using the Ruby language as a metamodel">
+  </description>
+  <maintainer>Sylvain Joyeux/sylvain.joyeux@m4x.org</maintainer>
+  <license>LGPLv3</license>
+
+  <depend package="utilrb" />
+  <depend package="kramdown" optional="1" />
+
+  <test_depend package="minitest" />
+  <test_depend package="flexmock" />
+</package>

data/test/suite.rb

@@ -0,0 +1,15 @@
+# Coverage is enabled by default when running the whole suite
+ENV['TEST_ENABLE_COVERAGE'] ||= '1'
+
+# Require all your test files here. Always prepend ./ and use the relative path
+# to the Ruby library root
+require 'metaruby/test'
+require './test/test_class'
+require './test/test_module'
+require './test/test_attributes'
+require './test/test_registration'
+require './test/test_dsls'
+
+# Put the root logger to DEBUG so that all debug blocks are executed
+MetaRuby.logger = Logger.new(File.open("/dev/null", 'w'))
+MetaRuby.logger.level = Logger::DEBUG

data/test/test_attributes.rb

@@ -0,0 +1,323 @@
+require 'metaruby/test'
+
+class TC_Models < MiniTest::Test
+    def test_inherited_attribute_class
+	a = Class.new do
+            class << self
+                extend MetaRuby::Attributes
+                inherited_attribute(:signature, :signatures) { Array.new }
+                inherited_attribute(:mapped, :map, :map => true) { Hash.new }
+            end
+	end
+	b = Class.new(a) do
+	    include Module.new # include an empty module between a and b to check that the module
+			       # is skipped transparently
+	    singleton_class.inherited_attribute(:child_attribute) { Array.new }
+	end
+	check_inherited_attribute(a, b)
+	
+	# Test for singleton class support
+	object = b.new
+	assert(object.singleton_class.respond_to?(:signatures))
+	object.singleton_class.signatures << :in_singleton
+	assert_equal([:in_singleton], object.singleton_class.signatures)
+    end
+
+    def check_inherited_attribute(base, derived)
+	assert(base.respond_to?(:each_signature))
+	assert(base.respond_to?(:signatures))
+	assert(!base.respond_to?(:has_signature?))
+	assert(!base.respond_to?(:find_signatures))
+
+	assert(base.respond_to?(:each_mapped))
+	assert(base.respond_to?(:map))
+	assert(base.respond_to?(:has_mapped?))
+
+        base.signatures << :in_base
+        base.map[:base] = 10
+        base.map[:overriden] = 20
+        assert_equal([:in_base], base.enum_for(:each_signature).to_a)
+        assert_equal([10].to_set, base.enum_for(:each_mapped, :base, false).to_set)
+
+	assert(!base.respond_to?(:child_attribute))
+	assert(!base.respond_to?(:each_child_attribute))
+	assert(derived.respond_to?(:child_attribute))
+	assert(derived.respond_to?(:each_child_attribute))
+
+        derived.signatures << :in_derived
+
+        derived.map[:overriden] = 15
+        derived.map[:derived] = 25
+
+        assert_equal([:in_derived, :in_base], derived.enum_for(:each_signature).to_a)
+        assert_equal([20, 15].to_set, derived.enum_for(:each_mapped, :overriden, false).to_set)
+        assert_equal([15].to_set, derived.enum_for(:each_mapped, :overriden, true).to_set)
+        assert_equal([25].to_set, derived.enum_for(:each_mapped, :derived).to_set)
+        assert_equal([[:base, 10], [:overriden, 20], [:overriden, 15], [:derived, 25]].to_set, derived.enum_for(:each_mapped, nil, false).to_set)
+        assert_equal([[:base, 10], [:overriden, 15], [:derived, 25]].to_set, derived.enum_for(:each_mapped, nil, true).to_set)
+    end
+
+    def test_inherited_attribute_non_mapping_promote
+	a = Class.new do
+            class << self
+                extend MetaRuby::Attributes
+                def promote_value(v)
+                    v
+                end
+                inherited_attribute(:value, :values) { Array.new }
+            end
+	end
+        b = flexmock(Class.new(a), 'b')
+        c = flexmock(Class.new(b), 'c')
+        d = flexmock(Class.new(c), 'd')
+
+        c.should_receive(:promote_value).with(10).and_return("10_b_c").once.ordered
+        d.should_receive(:promote_value).with("10_b_c").and_return(12).once.ordered
+        c.should_receive(:promote_value).with(11).and_return("11_b_c").once.ordered
+        d.should_receive(:promote_value).with("11_b_c").and_return(13).once.ordered
+        b.should_receive(:promote_value).with(0).and_return("0_b_c").once.ordered
+        c.should_receive(:promote_value).with("0_b_c").and_return("0_c_d").once.ordered
+        d.should_receive(:promote_value).with("0_c_d").and_return(2).once.ordered
+        b.should_receive(:promote_value).with(1).and_return("1_b_c").once.ordered
+        c.should_receive(:promote_value).with("1_b_c").and_return("1_c_d").once.ordered
+        d.should_receive(:promote_value).with("1_c_d").and_return(3).once.ordered
+
+        a.values << 0 << 1
+        b.values << 10 << 11
+        # Do NOT add anything at the level of C. Its promote_value method should
+        # still be called, though
+        d.values << 100 << 110
+        assert_equal [0, 1], a.each_value.to_a
+        assert_equal [100, 110, 12, 13, 2, 3], d.each_value.to_a
+    end
+
+    def test_inherited_attribute_mapping_promote
+	a = Class.new do
+            class << self
+                extend MetaRuby::Attributes
+                def promote_value(key, v)
+                end
+                def name; 'A' end
+                inherited_attribute(:value, :values, :map => true) { Hash.new }
+            end
+	end
+        b = Class.new(a)
+        c = Class.new(b)
+        d = Class.new(c)
+
+        flexmock(c).should_receive(:promote_value).with('b', 2).and_return("b2_b_c").once.ordered
+        flexmock(d).should_receive(:promote_value).with('b', "b2_b_c").and_return(15).once.ordered
+
+        flexmock(c).should_receive(:promote_value).with('c', 3).and_return("c3_b_c").once.ordered
+        flexmock(d).should_receive(:promote_value).with('c', "c3_b_c").and_return(16).once.ordered
+
+        flexmock(b).should_receive(:promote_value).with('a', 0).and_return("a0_a_b").once.ordered
+        flexmock(c).should_receive(:promote_value).with('a', "a0_a_b").and_return("a0_b_c").once.ordered
+        flexmock(d).should_receive(:promote_value).with('a', "a0_b_c").and_return(10).once.ordered
+
+        a.values.merge!('a' => 0, 'b' => 1)
+        b.values.merge!('b' => 2, 'c' => 3, 'd' => 4)
+        d.values.merge!('d' => 5, 'e' => 6)
+        assert_equal [['d', 5], ['e', 6], ['b', 15], ['c', 16], ['a', 10]], d.each_value.to_a
+    end
+
+    def test_inherited_attribute_mapping_promote_non_uniq
+	a = Class.new do
+            class << self
+                extend MetaRuby::Attributes
+                def promote_value(key, v)
+                end
+                inherited_attribute(:value, :values, :map => true) { Hash.new }
+            end
+	end
+        b = flexmock(Class.new(a), 'b')
+        c = flexmock(Class.new(b), 'c')
+        d = flexmock(Class.new(c), 'd')
+
+        c.should_receive(:promote_value).with('b', 2).and_return("b2_b_c").once.ordered
+        d.should_receive(:promote_value).with('b', "b2_b_c").and_return(12).once.ordered
+
+        c.should_receive(:promote_value).with('c', 3).and_return("c3_b_c").once.ordered
+        d.should_receive(:promote_value).with('c', "c3_b_c").and_return(13).once.ordered
+
+        c.should_receive(:promote_value).with('d', 4).and_return("d4_b_c").once.ordered
+        d.should_receive(:promote_value).with('d', "d4_b_c").and_return(14).once.ordered
+
+        b.should_receive(:promote_value).with('a', 0).and_return("a0_a_b").once.ordered
+        c.should_receive(:promote_value).with('a', "a0_a_b").and_return("a0_b_c").once.ordered
+        d.should_receive(:promote_value).with('a', "a0_b_c").and_return(10).once.ordered
+
+        b.should_receive(:promote_value).with('b', 1).and_return("b1_a_b").once.ordered
+        c.should_receive(:promote_value).with('b', "b1_a_b").and_return("b1_b_c").once.ordered
+        d.should_receive(:promote_value).with('b', "b1_b_c").and_return(11).once.ordered
+
+        a.values.merge!('a' => 0, 'b' => 1)
+        b.values.merge!('b' => 2, 'c' => 3, 'd' => 4)
+        d.values.merge!('d' => 5, 'e' => 6)
+        assert_equal [['d', 5], ['e', 6], ['b', 12], ['c', 13], ['d', 14], ['a', 10], ['b', 11]], d.each_value(nil, false).to_a
+    end
+
+    def test_inherited_attribute_mapping_promote_with_key_uniq
+	a = Class.new do
+            class << self
+                extend MetaRuby::Attributes
+                def promote_value(key, v)
+                end
+                inherited_attribute(:value, :values, :map => true) { Hash.new }
+            end
+	end
+        b = flexmock(Class.new(a), 'b')
+        c = flexmock(Class.new(b), 'c')
+        d = flexmock(Class.new(c), 'd')
+
+        c.should_receive(:promote_value).with('b', 2).and_return("b2_b_c").once.ordered
+        d.should_receive(:promote_value).with('b', "b2_b_c").and_return(12).once.ordered
+
+        a.values.merge!('a' => 0, 'b' => 1)
+        b.values.merge!('b' => 2, 'c' => 3, 'd' => 4)
+        d.values.merge!('d' => 5, 'e' => 6)
+        assert_equal [12], d.each_value('b', true).to_a
+    end
+
+    def test_inherited_attribute_mapping_promote_with_key_non_uniq
+	a = Class.new do
+            class << self
+                extend MetaRuby::Attributes
+                def promote_value(key, v)
+                end
+                inherited_attribute(:value, :values, :map => true) { Hash.new }
+            end
+	end
+        b = flexmock(Class.new(a), 'b')
+        c = flexmock(Class.new(b), 'c')
+        d = flexmock(Class.new(c), 'd')
+
+        c.should_receive(:promote_value).with('b', 2).and_return("b2_b_c").once.ordered
+        d.should_receive(:promote_value).with('b', "b2_b_c").and_return(12).once.ordered
+
+        b.should_receive(:promote_value).with('b', 1).and_return("b1_a_b").once.ordered
+        c.should_receive(:promote_value).with('b', "b1_a_b").and_return("b1_b_c").once.ordered
+        d.should_receive(:promote_value).with('b', "b1_b_c").and_return(11).once.ordered
+
+        a.values.merge!('a' => 0, 'b' => 1)
+        b.values.merge!('b' => 2, 'c' => 3, 'd' => 4)
+        d.values.merge!('d' => 5, 'e' => 6)
+        assert_equal [12, 11], d.each_value('b', false).to_a
+    end
+end
+
+describe MetaRuby::Attributes do
+    describe "#inherited_single_value_attribute" do
+        attr_reader :base, :sub, :subsub
+        describe "plain" do
+            before do
+                @base = Class.new do
+                    class << self
+                        extend MetaRuby::Attributes
+                        inherited_single_value_attribute :var
+                    end
+                end
+                @sub = Class.new(base)
+                @subsub = Class.new(sub)
+            end
+
+            it "should set the value if given an argument" do
+                base.var(10)
+                assert_equal 10, base.var
+            end
+            it "should return the value from the parent model if not set" do
+                base.var(10)
+                assert_equal 10, sub.var
+            end
+            it "should return nil if the instance variable is explicitly set to nil" do
+                base.var 10
+                sub.var nil
+                assert_equal nil, subsub.var
+            end
+        end
+
+        describe "with default" do
+            before do
+                @base = Class.new do
+                    class << self
+                        extend MetaRuby::Attributes
+                        inherited_single_value_attribute(:var) { 10 }
+                    end
+                end
+                @sub = Class.new(base)
+                @subsub = Class.new(sub)
+            end
+
+            it "should be accessible at each level" do
+                assert_equal 10, base.var
+                assert_equal 10, sub.var
+                assert_equal 10, subsub.var
+            end
+
+            it "should set only the bottom class" do
+                assert_equal 10, base.var
+                sub.var(nil)
+                assert_equal nil, sub.var
+                assert_equal nil, subsub.var
+            end
+        end
+
+        describe "with promotion" do
+            before do
+                @base = Class.new do
+                    class << self
+                        extend MetaRuby::Attributes
+                        def promote_var(value); value * 2 end
+                        inherited_single_value_attribute(:var)
+                    end
+                end
+                @sub = Class.new(base) do
+                    class << self
+                        def promote_var(value); value * 4 end
+                    end
+                end
+                @subsub = Class.new(sub) do
+                    class << self
+                        def promote_var(value); value - 10 end
+                    end
+                end
+            end
+
+            it "should apply the promotion method at each level" do
+                base.var(10)
+                assert_equal 10, base.var
+                assert_equal 40, sub.var
+                assert_equal 30, subsub.var
+            end
+        end
+
+        describe "with default with promotion" do
+            before do
+                @base = Class.new do
+                    class << self
+                        extend MetaRuby::Attributes
+                        def promote_var(value); value * 2 end
+                        inherited_single_value_attribute(:var) { 10 }
+                    end
+                end
+                @sub = Class.new(base) do
+                    class << self
+                        def promote_var(value); value * 4 end
+                    end
+                end
+                @subsub = Class.new(sub) do
+                    class << self
+                        def promote_var(value); value - 10 end
+                    end
+                end
+            end
+
+            it "should apply the promotion method at each level" do
+                assert_equal 10, base.var
+                assert_equal 40, sub.var
+                assert_equal 30, subsub.var
+            end
+        end
+    end
+end
+

data/test/test_class.rb

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