metaruby 1.0.0.rc1 → 1.0.0.rc2

data/manifest.xml

@@ -1,12 +1,9 @@
 <package>
-  <description brief="Modelling using the Ruby language as a metamodel">
+  <description brief="">
   </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/metaruby.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'metaruby/version'
+
+Gem::Specification.new do |s|
+    s.name = "metaruby"
+    s.version = MetaRuby::VERSION
+    s.authors = ["Sylvain Joyeux"]
+    s.email = "sylvain.joyeux@m4x.org"
+    s.summary = "Modelling using the Ruby language as a metamodel"
+    s.description = "MetaRuby is a set of module and classes that help one use the Ruby type system as a basis for modelling."
+    s.homepage = "http://rock-robotics.org"
+    s.licenses = ["BSD"]
+
+    s.require_paths = ["lib"]
+    s.extensions = []
+    s.extra_rdoc_files = ["README.md"]
+    s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+
+    s.add_runtime_dependency "utilrb", ">= 2.1.0.a"
+    s.add_runtime_dependency "kramdown"
+    s.add_development_dependency "flexmock", ">= 2.0.0"
+    s.add_development_dependency "minitest", ">= 5.0", "~> 5.0"
+    s.add_development_dependency "coveralls"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metaruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc1
+  version: 1.0.0.rc2
 platform: ruby
 authors:
 - Sylvain Joyeux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-13 00:00:00.000000000 Z
+date: 2015-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: utilrb
@@ -16,84 +16,90 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.4
+        version: 2.1.0.a
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.4
+        version: 2.1.0.a
 - !ruby/object:Gem::Dependency
-  name: hoe-yard
+  name: kramdown
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.2
-  type: :development
+        version: '0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: flexmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 2.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
-  name: hoe
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.13'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
     - - "~>"
       - !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
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: MetaRuby is a set of module and classes that help one use the Ruby type
+  system as a basis for modelling.
+email: sylvain.joyeux@m4x.org
 executables: []
 extensions: []
 extra_rdoc_files:
-- History.txt
-- Manifest.txt
 - README.md
 files:
-- ".gemtest"
-- History.txt
-- Manifest.txt
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
 - README.md
 - Rakefile
+- bin/.gitattributes
 - lib/metaruby.rb
 - lib/metaruby/class.rb
 - lib/metaruby/dsls.rb
@@ -105,6 +111,7 @@ files:
 - lib/metaruby/gui/html/button.rb
 - lib/metaruby/gui/html/collection.rb
 - lib/metaruby/gui/html/exception_view.css
+- lib/metaruby/gui/html/fragment.rhtml
 - lib/metaruby/gui/html/jquery.min.js
 - lib/metaruby/gui/html/jquery.selectfilter.js
 - lib/metaruby/gui/html/jquery.tagcloud.min.js
@@ -123,22 +130,16 @@ files:
 - lib/metaruby/module.rb
 - lib/metaruby/registration.rb
 - lib/metaruby/test.rb
+- lib/metaruby/version.rb
+- lib/yard-metaruby.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
+- metaruby.gemspec
+homepage: http://rock-robotics.org
 licenses:
-- LGPLv3+
+- BSD
 metadata: {}
 post_install_message: 
-rdoc_options:
-- "--title"
-- TestMetaruby Documentation
-- "--quiet"
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -153,8 +154,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
 summary: Modelling using the Ruby language as a metamodel
 test_files: []
+has_rdoc: 

data/History.txt

@@ -1 +0,0 @@
-===

data/Manifest.txt

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

data/test/suite.rb

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

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