moosex 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: adec6f28fb1f2d50839aa7eccc0aca75d59541f2
-  data.tar.gz: 4883921244c4bd67a5f767a5cc4cdc03e91c8874
+  metadata.gz: bc3a722220a8aed4beee90b8df3a3c8194433ce2
+  data.tar.gz: 8818053e9e74a8c21be1fb3549e3d53d8574ba24
 SHA512:
-  metadata.gz: 95cee02f36c62c6e8864fb4aab9cbfacc9d552ca81f29283ae67fef75cb861de24a16a1716e352ad947ff9e1889477957dbf633e2d44969e9c35b10f249fea79
-  data.tar.gz: 1a5ae462cf7a223f03ae19433ad8b7a3361e6ce3137610c86395450766f0be01a4de959e1d41a353d9c89cf21b3591d877a8400f38f1d50ca8f2ea4892d8eedf
+  metadata.gz: 17f3adf263961e0f83551cf15eb92e102f60623173533f70ddce374c72409119d4d032993760f2ada6a1884817ba3c6869104ab2531891da3e576a6249f79e87
+  data.tar.gz: f87783b850d1e43d0be4eaaf89b66967556387406d767ae80f4709f228f75056055b92137561620a492ff94327996e5caf0885e0ff845473c35982e22c69d9af

data/Changelog

@@ -1,3 +1,9 @@
+0.0.15 - 2013-02-07
+    - after, before, around now accept more than one method name
+    - add basic event support #45
+    - add parametric roles #44
+    - add init method to enable warnings and exceptions #43
+
 0.0.14 - 2013-02-05
 	- roles with around/before/after basic support #41
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    moosex (0.0.14)
+    moosex (0.0.15)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -587,7 +587,7 @@ Roles are Modules with steroids. If you include the MooseX module in another mod
 require 'moosex'
 
 module Eq
-  include MooseX.disable_warnings() # or enable_warningss (default)
+  include MooseX
 
   requires :equal
 
@@ -603,11 +603,10 @@ module Valuable
 end 
 
 class Currency
-  include Valuable
-  include Eq  # will warn unless disable_warnings was called.
-              # to avoid warnings, you should include after  
-              # define all required modules,
-
+  include Valuable.init(warnings: false) # default is true!
+  include Eq  # default will warn about equal missing. 
+              # alternative: include after equal definition!
+              
   def equal(other)
     self.value == other.value
   end
@@ -622,14 +621,65 @@ c1.equal(c2)          # true, they have the same value
 c1.no_equal(c2)       # will return false
 ```
 
-Roles can support has to describe attributes, and you can reuse code easily. You can also use after/before/around only in methods defined/imported in that Module.
-
-For example, we can add a 'after' block for no_equal inside Eq, but not for equal - this limitation will be fixed soon (see issue #41 @ github).
+Roles can support has to describe attributes, and you can reuse code easily. 
 
 ### requires
 
 You can also mark one or more methods as 'required'. When you do this, we will raise one exception if you try to create a new instance and the class does not implement it. It is a safe way to create interfaces or abstract classes. It uses respond_to? to verify.
 
+
+## Parametric Roles
+
+Parametric roles is a good way of reuse code based on roles. For example, to create one or more attributes in the class who includes our role, we just add the code to be executed in the on_init hook.
+
+```ruby
+module EasyCrud
+  include MooseX
+  
+  on_init do |*attributes|
+    attributes.each do | attr |
+      has attr, { is: :rw, predicate: "has_attr_#{attr}_or_not?" }
+    end
+  end
+end
+
+class LogTest
+  include EasyCrud.init(:a, :b)
+   ...
+```
+
+when we call `init` with arguments, we will call all on_init blocks defined in the role. In this example we inject attributes 'a' and 'b' with reader/writter and a predicate based on the name ex: `has_attr_a_or_not?`
+
+### composable parametric roles
+
+To combine one or more parametric roles to another parametric role you should do something like this:
+
+```ruby
+module Logabble2
+  include MooseX
+    
+  on_init do |args|
+    args[:klass] = self
+    include Logabble.init(args)
+  end  
+end
+
+module Logabble
+  include MooseX
+   
+  on_init do | args |
+
+    klass  = args[:klass]    || self  # <= THIS will guarantee you will
+    methods = args[:methods] || []    #    modify the right class
+
+    methods.each do |method|
+      klass.around(method) do |original, object, *args|
+        # add log around method
+        # call original method
+        # return
+    ...
+```
+
 ## BUILD
 
 If you need run some code after the creation of the object (like some extra validation), you should implement the BUILD method.
@@ -680,6 +730,55 @@ ex2 = BuildArgsExample2.new(1)   # x == 1, y == 8
 ex3 = BuildArgsExample2.new()    # x == 4, y == 8
 ```
 
+## EVENTS
+
+MooseX has a built-in event system, and it should be useful if you want to avoid after/before hooks ( depends of what is yout problem ).
+
+```ruby
+require 'moosex'
+require 'moosex/event'
+
+class Example
+  include MooseX
+  include MooseX::Event
+  
+  def ping
+    self.emit(:pinged)
+  end
+end
+
+e = Example.new
+
+e.on(:pinged) do |object|
+    puts "Ping!"
+end
+
+e.once(:pinged) do |object|
+    puts "Ping Once!"
+end
+  
+e.ping # will print two messages, "Ping!" and "Ping Once!"
+e.ping # will print just "Ping!"  
+
+e.remove_all_listeners(:pinged)
+
+e.ping # will no longer print nothing
+
+# you can use arguments
+# consider you have one logger attribute in this example
+listener = e.on(:error) do |obj, message|
+    obj.logger.fatal("Error: #{message}")
+end
+
+e.emit(:error, "ops") # will log, as fatal, "Error: ops"
+
+e.remove_listener( error: listener )
+
+e.emit(:error, "...") # will no longer log nothing
+```
+
+If you want to restrict how many different events you can handle, you should overload the `has_events` method and return one array of valid events. If you want accept all, you should return nil (default).
+
 ## IMPORTANT
 
 This module is experimental. I should test more and more to be possible consider this "production ready". If you find some issue/bug please add here: https://github.com/peczenyj/MooseX/issues

data/lib/moosex.rb

@@ -9,17 +9,28 @@ require "moosex/version"
 require "moosex/types"
 
 module MooseX
-	$MOOSEX_DEBUG = true
-
-	def MooseX.enable_warnings()
-		$MOOSEX_DEBUG = false
-		MooseX
-	end	
-
-	def MooseX.disable_warnings()
-		$MOOSEX_DEBUG = false
-		MooseX
-	end	
+	@@MOOSEX_WARNINGS = true
+	@@MOOSEX_FATAL    = false
+	
+	class FatalError < StandardError
+	end  
+	
+	def self.warn(x, *c)
+	  raise FatalError, "[MooseX] exception: #{x}",*c if @@MOOSEX_FATAL
+    Kernel.warn("[MooseX] warning: #{x}") if @@MOOSEX_WARNINGS
+	end
+	
+	def self.init(args={})
+	  if args.has_key? :warnings
+	    @@MOOSEX_WARNINGS = !! args[:warnings]
+	  end
+	  
+	  if args.has_key? :fatal
+	    @@MOOSEX_FATAL = !! args[:fatal]
+	  end
+	  
+	  self
+  end
 
 	class RequiredMethodNotFoundError < NameError
 	end
@@ -27,8 +38,15 @@ module MooseX
 	def MooseX.included(c)
 	
 		c.extend(MooseX::Core)
+
+    def c.init(*args)
+      __meta.roles.each{|role| role.call(*args)}
+      
+      self
+    end
 		
 		def c.included(x)
+		  
 			MooseX.included(x)
 			x.__meta.load_from(self.__meta)
 
@@ -39,7 +57,7 @@ module MooseX
 
 			x.__meta.requires.each do |method|
 				unless x.public_instance_methods.include? method
-					warn "[MooseX] you must implement method '#{method}' in #{x} #{x.class}: required" if $MOOSEX_DEBUG
+					MooseX.warn "you must implement method '#{method}' in #{x} #{x.class}: required"# if $MOOSEX_DEBUG
 				end	
 			end			
 		end
@@ -80,12 +98,13 @@ module MooseX
 	end
 	
 	class Meta
-		attr_reader :attrs, :requires, :before, :after, :around
+		attr_reader :attrs, :requires, :before, :after, :around, :roles
 
 		def initialize(old_meta=nil)
 			@initialized = false
 			@attrs    = {}
 			@requires = []
+			@roles    = []
 			@before   = Hash.new { |hash, key| hash[key] = [] }
 			@after    = Hash.new { |hash, key| hash[key] = [] }
 			@around   = Hash.new { |hash, key| hash[key] = [] }
@@ -136,13 +155,22 @@ module MooseX
 		def add_around(method_name, block)
 			@around[method_name] << block.clone
 		end
+		
+		def add_role(block)
+		  @roles << block
+    end
 
 		def init_klass(klass)
 			#return if @initialized
 
 			[@before.keys + @after.keys + @around.keys].flatten.uniq.each do |method_name|
-				method = klass.instance_method method_name
-
+			  begin
+				  method = klass.instance_method method_name
+        rescue => e
+          MooseX.warn "Unable to apply hooks (after/before/around) in #{klass}::#{method_name} : #{e}" # if $MOOSEX_DEBUG
+          next
+        end  
+        
 				before = @before[method_name]
 				after  = @after[method_name]
 				around = @around[method_name]
@@ -168,7 +196,7 @@ module MooseX
 		def init(object, args)
 			@attrs.each_pair{ |symbol, attr| attr.init(object, args) }
 
-			warn "[MooseX] unused attributes #{args} for #{object.class}" if $MOOSEX_DEBUG && ! args.empty?	
+			MooseX.warn "unused attributes #{args} for #{object.class}", caller unless args.empty?	
 
 			@requires.each do |method|
 				unless object.respond_to? method
@@ -180,49 +208,62 @@ module MooseX
 	end	
 
 	module Core
-		def after(method_name, &block)
-			begin
-				method = instance_method method_name
-
-				define_method method_name do |*args|
-					result = method.bind(self).call(*args)
-					block.call(self,*args)
-					result
-				end
-			rescue => e
-				__meta.add_after(method_name, block)
-			end	
+	  def on_init(&block)
+	    __meta.add_role(block)
+	  end
+	  	  
+		def after(*methods_name, &block)
+  	  methods_name.each do |method_name|  
+  			begin
+  				method = instance_method method_name
+
+  				define_method method_name do |*args|
+  					result = method.bind(self).call(*args)
+  					block.call(self,*args)
+  					result
+  				end
+  			rescue => e
+  			  MooseX.warn "unable to apply hook after in #{method_name} @ #{self}: #{e}", caller() if self.is_a?(Class)	
+  				__meta.add_after(method_name, block)
+  			end
+  		end	
 		end
 
-		def before(method_name, &block)
-			begin
-				method = instance_method method_name
-
-				define_method method_name do |*args|
-					block.call(self,*args)
-					method.bind(self).call(*args)
-				end
-			rescue => e
-				__meta.add_before(method_name, block)			
-			end	
+		def before(*methods_name, &block)
+		  methods_name.each do |method_name|
+  			begin
+  				method = instance_method method_name
+
+  				define_method method_name do |*args|
+  					block.call(self,*args)
+  					method.bind(self).call(*args)
+  				end
+  			rescue => e
+  			  MooseX.warn "unable to apply hook before in #{method_name} @ #{self}: #{e}", caller() if self.is_a?(Class)	
+  				__meta.add_before(method_name, block)			
+  			end	
+			end
 		end
 
-		def around(method_name, &block)
-			begin			
-				method = instance_method method_name
+		def around(*methods_name, &block)
+  		methods_name.each do |method_name|  		    
+  			begin
+  			  method = instance_method method_name
 
-				code = Proc.new do | o, *a| 
-					method.bind(o).call(*a) 
-				end
+  				code = Proc.new do | o, *a| 
+  					method.bind(o).call(*a) 
+  				end
 
-				define_method method_name do |*args|
+  				define_method method_name do |*args|
 					
-					block.call(code, self,*args)
+  					block.call(code, self,*args)
 					
-				end		
-			rescue => e	
-				__meta.add_around(method_name, block)
-			end
+  				end		
+  			rescue => e
+  			  MooseX.warn "unable to apply hook around in #{method_name} @ #{self}: #{e}", caller() if self.is_a?(Class)			  	
+  				__meta.add_around(method_name, block)
+  			end
+  		end	
 		end
 
 		def requires(*methods)
@@ -416,7 +457,7 @@ module MooseX
 			end,
 		};
 
-		def initialize(a, o, x)
+		def initialize(a, o ,x)
 			#o ||= {}
 			# todo extract this to a framework, see issue #21 on facebook
 			o = DEFAULTS.merge({
@@ -470,7 +511,7 @@ module MooseX
 			@coerce      = o.delete(:coerce)
 			@methods     = {}
 
-			warn "[MooseX] unused attributes #{o} for attribute #{a} @ #{x} #{x.class}" if $MOOSEX_DEBUG && ! o.empty?	
+			MooseX.warn "Unused attributes #{o} for attribute #{a} @ #{x} #{x.class}",caller() if ! o.empty?	
 
 			if @reader 
 				@methods[@reader] = generate_reader

data/lib/moosex/event.rb

@@ -0,0 +1,71 @@
+require 'moosex'
+require 'moosex/types'
+
+module MooseX
+  module Event  
+    class EventException < StandardError
+    end  
+    class EventListener
+      include MooseX
+      
+      has once:  { is: :rw, reader: :once?  }
+      has event: { is: :ro, handles: { :respond_to_event? => :== } }
+      has code:  { is: :ro, handles: :call }
+
+    end
+    
+    include MooseX
+    include MooseX::Types
+    
+    has listeners: {
+      is: :private,
+      isa: isArray(EventListener),
+      default: lambda{ [] },
+    }
+
+    def has_events
+      nil
+    end
+    
+    def on(event, &block)
+      add_event_listener(event, false, block) 
+    end
+
+    def once(event, &block)
+      add_event_listener(event, true, block)
+    end
+        
+    def emit(event, *args)
+      listeners.select{|l| l.respond_to_event?(event) }.each{|l| l.call(self, *args) }
+      listeners.delete_if {|l| l.once? }
+    end
+    
+    def remove_all_listeners(event)
+      listeners.delete_if {|l| l.respond_to_event?(event) }
+    end
+
+    def remove_listener(data)
+      data.each_pair do |event, listener|
+        listeners.delete(listener)
+      end  
+    end
+    
+    private
+    def add_event_listener(event, once, code)        
+      listener = EventListener.new(event: event, once: once, code: code)
+        
+      listeners << listener
+      
+      listener
+    end  
+
+    before(:add_event_listener, :emit) do |obj, event, *rest|
+ 
+      if ! obj.has_events.nil? && ! [ obj.has_events ].flatten.include?(event)
+        
+        raise EventException, "Event '#{event.inspect}' not supported, this class only allow: #{obj.has_events.inspect}",caller
+        
+      end    
+    end
+  end
+end

data/lib/moosex/version.rb

@@ -1,3 +1,3 @@
 module MooseX
-  VERSION = "0.0.14"
+  VERSION = "0.0.15"
 end

data/spec/event_spec.rb

@@ -0,0 +1,164 @@
+require 'moosex'
+require 'moosex/event'
+
+class EventExample
+  include MooseX
+  include MooseX::Event
+  
+  def has_events
+    [ :pinged, :ponged ]
+  end
+  
+  def ping
+    self.emit(:pinged)
+  end
+  
+  def pong(message)
+    self.emit(:ponged, message)
+  end
+  
+end
+
+class EventExample2 < EventExample
+  def has_events; end
+end
+
+describe EventExample do
+  it "EventExample should emit ping" do
+    logger = double
+    e = EventExample.new
+    
+    logger.should_receive(:on_pinged).with(e).once()
+    e.on(:pinged) do |object|
+      logger.on_pinged(object)
+    end
+    e.ping
+  end
+  
+  it "EventExample should emit ping twice, on should receive twice but once will receive once" do
+    logger1 = double
+    logger2 = double
+    
+    e = EventExample.new
+    
+    logger1.should_receive(:on_pinged).with(e).twice()
+    logger2.should_receive(:on_pinged).with(e).once()
+    
+    e.on(:pinged) do |object|
+      logger1.on_pinged(object)
+    end
+
+    e.once(:pinged) do |object|
+      logger2.on_pinged(object)
+    end
+        
+    e.ping
+    e.ping
+  end  
+
+  it "EventExample should emit ping twice, but you remove all listeners" do
+    logger1 = double
+    logger2 = double
+    
+    e = EventExample.new
+    
+    logger1.should_receive(:on_pinged).with(e).once()
+    logger2.should_receive(:on_pinged).with(e).once()
+    
+    e.on(:pinged) do |object|
+      logger1.on_pinged(object)
+    end
+
+    e.on(:pinged) do |object|
+      logger2.on_pinged(object)
+    end
+        
+    e.ping
+    
+    e.remove_all_listeners( :pinged )
+    
+    e.ping
+  end
+  
+  it "EventExample should emit ping twice, but you remove one listener" do
+    logger1 = double
+    logger2 = double
+    
+    e = EventExample.new
+    
+    logger1.should_receive(:on_pinged).with(e).twice()
+    logger2.should_receive(:on_pinged).with(e).once()
+    
+    e.on(:pinged) do |object|
+      logger1.on_pinged(object)
+    end
+
+    listener = e.on(:pinged) do |object|
+      logger2.on_pinged(object)
+    end
+        
+    e.ping
+    
+    e.remove_listener( pinged: listener )
+    
+    e.ping
+  end  
+
+  it "should not add listener to a non supported event" do
+    e = EventExample.new
+    expect {  
+      e.on(:xxx) {}
+    }.to raise_error(MooseX::Event::EventException,
+      "Event ':xxx' not supported, this class only allow: [:pinged, :ponged]")
+  end
+  
+  it "should not add listener to a non supported event" do
+    e = EventExample.new
+    expect {  
+      e.once(:xxx) {}
+    }.to raise_error(MooseX::Event::EventException,
+      "Event ':xxx' not supported, this class only allow: [:pinged, :ponged]")
+  end
+    
+  it "should not emit a non supported event" do
+    e = EventExample.new
+    expect {  
+      e.emit(:xxx)
+    }.to raise_error(MooseX::Event::EventException,
+      "Event ':xxx' not supported, this class only allow: [:pinged, :ponged]")
+  end
+  
+  it "should emit ping and pong" do
+    e = EventExample.new
+    logger = double
+    logger.should_receive(:receive_from_ping).with(e,1).once();
+    
+    e.once(:pinged) do |obj|
+      obj.pong(1)  
+    end  
+    e.on(:ponged) do |obj, msg|
+      logger.receive_from_ping(obj, msg)
+    end
+    
+    e.ping
+    e.ping
+  end  
+end
+
+describe EventExample2 do
+  it "should not add listener to a non supported event" do
+    e = EventExample2.new
+    e.once(:xxx) {}
+  end
+    
+  it "should not emit a non supported event" do
+    e = EventExample2.new
+
+    logger = double
+    logger.should_receive(:called_from_xxx).once()
+    
+    e.once(:xxx) { logger.called_from_xxx }
+
+    e.emit(:xxx)
+  end  
+end

data/spec/parametric_role_spec.rb

@@ -0,0 +1,174 @@
+require 'moosex'
+require 'logger'
+
+module Logabble
+  include MooseX
+  
+  has logger: {
+    is: :ro,
+    #isa: Logger,
+    default: lambda{ 
+      logger = Logger.new(STDOUT) 
+      logger.level = Logger::INFO
+      logger
+    },
+    handles: {
+      log_info: :info, 
+      log_warn: :warn, 
+      log_fatal: :fatal, 
+      log_debug: :debug 
+    }
+  }
+  
+  on_init do | args |
+
+    klass  = args[:klass]    || self  # this is necessary if you need composable Roles
+    methods = args[:methods] || []    
+
+    methods.each do |method|
+      klass.around(method) do |original, object, *args|
+      
+        object.log_info([args])
+        
+        begin
+        result = original.call(object, *args)
+        
+        object.log_warn(result)
+        
+        result
+        rescue => e
+          object.log_fatal(e.message)
+          nil
+        end 
+      end
+      
+    end
+    
+  end
+  
+end
+
+module Logabble2
+  include MooseX
+  
+  has y: { is: :rw }
+  
+  on_init do |args|
+    args[:klass] = self
+    include Logabble.init(args)
+  end  
+end
+
+
+module EasyCrud
+  include MooseX
+  
+  on_init do |*attributes|
+    attributes.each do | attr |
+      has attr, { is: :rw, predicate: "has_attr_#{attr}_or_not?" }
+    end
+  end
+end
+
+class LogTest
+  include EasyCrud.init(:a, :b)
+  
+  def foo; 1 ; end
+  def bar(a); 1 / a ; end
+  def baz(a,b); 1 + a + b; end
+  
+  include Logabble.init(methods: [:foo, :bar, :baz])
+end
+
+class LogTest2
+  include MooseX
+  
+  def foo; 1 ; end
+  def bar(a); 1 / a ; end
+  def baz(a,b); 1 + a + b; end
+  
+  include Logabble2.init(methods: [:foo, :bar, :baz, :y=])
+end
+
+describe LogTest do
+  it "should has a logger" do
+    l = LogTest.new()
+    l.logger.is_a?(Logger).should be_true
+  end
+
+  it "should has :a and :b attr" do
+    l = LogTest.new()
+    
+    l.has_attr_a_or_not?.should be_false
+    l.has_attr_b_or_not?.should be_false
+  end
+    
+  it "should has :a and :b attrs defined" do
+    l = LogTest.new(a: 1, b: 2)
+    
+    l.has_attr_a_or_not?.should be_true
+    l.has_attr_b_or_not?.should be_true
+    
+    l.a.should == 1
+    l.b.should == 2
+    
+    l.a = 5
+    l.b = 6
+    
+    l.a.should == 5
+    l.b.should == 6    
+  end
+   
+  it "call bar(0) should call logger info and fatal" do
+    logger = double
+    logger.should_receive(:info).with([[0]])
+    logger.should_receive(:fatal).with("divided by 0")
+    
+    l = LogTest.new(logger: logger)
+    l.bar(0)
+  end
+  
+  it "call bar(1) should call logger info and warn" do
+    logger = double
+    logger.should_receive(:info).with([[2]])
+    logger.should_receive(:warn).with(1/2)
+    
+    l = LogTest.new(logger: logger)
+    l.bar(2)
+  end  
+end
+
+describe LogTest2 do
+  it "should has a logger" do
+    l = LogTest2.new()
+    l.logger.is_a?(Logger).should be_true
+  end
+  
+  it "call bar(0) should call logger info and fatal" do
+    logger = double
+    logger.should_receive(:info).with([[0]])
+    logger.should_receive(:fatal).with("divided by 0")
+    
+    l = LogTest2.new(logger: logger)
+    l.bar(0)
+  end
+  
+  it "call bar(1) should call logger info and warn" do
+    logger = double
+    logger.should_receive(:info).with([[2]])
+    logger.should_receive(:warn).with(1/2)
+    
+    l = LogTest2.new(logger: logger)
+    l.bar(2)
+  end  
+  
+  it "call y= should call logger" do
+    log = double
+    log.should_receive(:info).with([[123]])
+    log.should_receive(:warn).with(123)
+    
+    l = LogTest2.new(logger: log)
+    l.y = 123
+  end
+  
+end

data/spec/role_spec.rb

@@ -18,6 +18,7 @@ module ComplexRole
 	end	
 
 	class Currency
+	  include MooseX
 		include Valuable
 		include Eq  # will warn unless disable_warnings was called.
                     # to avoid warnings, you should include after  

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moosex
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.15
 platform: ruby
 authors:
 - Tiago Peczenyj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-06 00:00:00.000000000 Z
+date: 2014-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,6 +87,7 @@ files:
 - README.md
 - Rakefile
 - lib/moosex.rb
+- lib/moosex/event.rb
 - lib/moosex/types.rb
 - lib/moosex/version.rb
 - moosex.gemspec
@@ -98,11 +99,13 @@ files:
 - spec/buildargs_spec.rb
 - spec/coerce_spec.rb
 - spec/complex_type_spec.rb
+- spec/event_spec.rb
 - spec/foo_spec.rb
 - spec/hooks_spec.rb
 - spec/lazy_spec.rb
 - spec/lol_spec.rb
 - spec/moosex_spec.rb
+- spec/parametric_role_spec.rb
 - spec/point_spec.rb
 - spec/proxy_spec.rb
 - spec/role_spec.rb
@@ -140,15 +143,16 @@ test_files:
 - spec/buildargs_spec.rb
 - spec/coerce_spec.rb
 - spec/complex_type_spec.rb
+- spec/event_spec.rb
 - spec/foo_spec.rb
 - spec/hooks_spec.rb
 - spec/lazy_spec.rb
 - spec/lol_spec.rb
 - spec/moosex_spec.rb
+- spec/parametric_role_spec.rb
 - spec/point_spec.rb
 - spec/proxy_spec.rb
 - spec/role_spec.rb
 - spec/spec_helper.rb
 - spec/trigger_spec.rb
 - spec/types_spec.rb
-has_rdoc: