Add Adamantium::ModuleMethods#included

lib/adamantium/module_methods.rb

@@ -90,6 +90,19 @@ def original_instance_method(name)
 
   private
 
+    # Hook called when module is included
+    #
+    # @param [Module] descendant
+    #   the module including ModuleMethods
+    #
+    # @return [self]
+    #
+    # @api private
+    def included(descendant)
+      super
+      descendant.module_eval { include Adamantium }
+    end
+
     # Memoize the named method
     #
     # @param [Symbol] method_name

spec/unit/adamantium/module_methods/included_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Adamantium::ModuleMethods, '#included' do
+  subject { descendant.instance_exec(object) { |mod| include mod } }
+
+  let(:object)     { Module.new.extend(described_class) }
+  let(:descendant) { Class.new                          }
+  let(:superclass) { Module                             }
+
+  before do
+    # Prevent Module.included from being called through inheritance
+    Adamantium.stub(:included)
+  end
+
+  around do |example|
+    # Restore included method after each example
+    superclass.class_eval do
+      alias_method :original_included, :included
+      example.call
+      undef_method :included
+      alias_method :included, :original_included
+    end
+  end
+
+  it 'delegates to the superclass #included method' do
+    # This is the most succinct approach I could think of to test whether the
+    # superclass#included method is called. All of the built-in rspec helpers
+    # did not seem to work for this.
+    included = false
+    superclass.class_eval { define_method(:included) { |_| included = true } }
+    expect { subject }.to change { included }.from(false).to(true)
+  end
+
+  it 'includes Adamantium into the descendant' do
+    subject
+    expect(descendant.included_modules).to include(Adamantium)
+  end
+end