super_module 1.2.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 80fcc01874eafdb2bf870cd3e06f55a135d830d1
-  data.tar.gz: 7c9b6e1a8b5f16b19ff60755c2258b3e67da3484
+SHA256:
+  metadata.gz: 70513ad566652aaf58d9da92fe22c598be383f3df25700a25245b0862e9b5580
+  data.tar.gz: 3002cb8ce8d0e853b1228f29f952034a7f9c2520c9635806860bde0959fe448b
 SHA512:
-  metadata.gz: e0f9ac72e8ae4aaf4fee64d9aaae54a996de85d7e18b3f5de523bef20bc0b1362bca31bc3317888fe1de405468cc43ef117de47098792ffbb98642deb42de3d5
-  data.tar.gz: 9e0dd6a4468c5719a99197a2136c4a9b5078009c2b78aa5fb0feb5674f322b2020648658fa279bd43caad6b68074f32eeb2e2836c23927d61c428dcd4985b9d3
+  metadata.gz: e20a35408bb4be154120310d932fe679d0ddc1224817886c1235cfdcb89750a6fd9655d9b0432e9f5441504122d714042da22527ac8ebb1316f3f3e6b1359021
+  data.tar.gz: 04db18d5c5991a8342d868a56aa8143b71b4775dd7f7f4a4cb919f9fb0c1073775602441fe41e0d19630bac5f690f52ce9c4cca5170d58bc3af1fafda87a862e

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Change Log
+
+## 1.3.0
+
+- Dropped support for SuperModule 2 Beta syntax, reverting to V1 syntax as the default
+- Added `included_super_module` method to allow modules to call it if they need to redefine `self.included` for meta-programming.
+
+## 1.2.2
+
+* Relaxed dependency on `method_source` gem version
+
+## v2 Beta (v1.2.1)
+
+* Standalone super module usage (e.g. direct class method invocation)
+
+## v2 Beta (v1.2.0)
+
+* New `super_module(name)` syntax
+* Much simpler implementation with guaranteed correctness and no performance hit
+* Less memory footprint by not requiring method_source Ruby gem for v2 syntax
+* Backwards compatibility with v1 syntax
+
+## v1.1.1
+
+* Added support for private and protected methods
+* Added many more RSpec test cases, including testing of empty and comment containing singleton methods
+
+## v1.1.0
+
+ * Brand new `self`-friendly algorithm that ensures true mixing of super module singleton methods into the including base class or module, thus always returning the actual base class or module `self` when invoking a super module inherited singleton method (thanks to [Banister](https://github.com/banister) for [reporting previous limitation on Reddit and providing suggestions](http://www.reddit.com/r/ruby/comments/30j66y/step_aside_activesupportconcern_supermodule_is/))
+ * New `included_super_modules` inherited singleton method that provides developer with a list of all included super modules similar to the Ruby `included_modules` method.
+ * No more use for method_missing (Thanks to Marc-André Lafortune for bringing up as a previous limitation in [AirPair article reviews](https://www.airpair.com/ruby/posts/step-aside-activesupportconcern-supermodule-is-the-new-sheriff-in-town))
+ * New dependency on [Banister](https://github.com/banister)'s [method_source](https://github.com/banister/method_source) library to have the self-friendly algorithm eval inherited class method sources into the including base class or module.
+ * Refactorings, including break-up of the original SuperModule into 3 modules in separate files
+ * More RSpec test coverage, including additional method definition scenarios, such as when adding dynamically via `class_eval` and `define_method`

data/README.md

@@ -1,5 +1,6 @@
-# <img src="https://raw.githubusercontent.com/AndyObtiva/super_module/master/SuperModule.jpg" alt="SuperModule" align="left" height="50" /> &nbsp; SuperModule 2 Beta
+# <img src="https://raw.githubusercontent.com/AndyObtiva/super_module/master/SuperModule.jpg" alt="SuperModule" align="left" height="50" /> &nbsp; SuperModule 1.3
 [![Gem Version](https://badge.fury.io/rb/super_module.svg)](http://badge.fury.io/rb/super_module)
+[![Build Status](https://api.travis-ci.org/AndyObtiva/super_module.svg?branch=master)](https://travis-ci.org/AndyObtiva/super_module)
 [![Coverage Status](https://coveralls.io/repos/AndyObtiva/super_module/badge.svg?branch=master)](https://coveralls.io/r/AndyObtiva/super_module?branch=master)
 [![Code Climate](https://codeclimate.com/github/AndyObtiva/super_module.svg)](https://codeclimate.com/github/AndyObtiva/super_module)
 
@@ -9,7 +10,9 @@ Ruby offers one workaround in the form of implementing the hook method [`Module.
 
 Another workaround is [`ActiveSupport::Concern`](http://api.rubyonrails.org/classes/ActiveSupport/Concern.html), a Rails library that attempts to ease some of the boilerplate pain by offering a [DSL](http://www.infoq.com/news/2007/06/dsl-or-not) layer on top of [`Module.included(base)`](http://ruby-doc.org/core-2.2.1/Module.html#method-i-included). Unfortunately, while it helps improve readability a bit, it adds even more boilerplate idiom cruft, thus feeling no more than putting a band-aid on the problem.
 
-But do not fear, [SuperModule](https://rubygems.org/gems/super_module) comes to the rescue! By declaring your module as a `super_module`, it will simply behave as one would expect and automatically include class methods along with instance methods, without any further work needed.
+But do not fear, [SuperModule](https://rubygems.org/gems/super_module) comes to the rescue! By declaring your module as a SuperModule, it will simply behave as one would expect and automatically include class methods along with instance methods, without any further work needed.
+
+Used in my other project: [Glimmer](https://github.com/AndyObtiva/Glimmer) (Ruby Desktop GUI Library)
 
 ## Introductory Comparison
 
@@ -73,7 +76,8 @@ A step forward that addresses the boiler-plate repetitive code concern, but is o
 #### 3) [SuperModule](https://github.com/AndyObtiva/super_module)
 
 ```ruby
-super_module :UserIdentifiable do
+module UserIdentifiable
+  include SuperModule
   include ActiveModel::Model
 
   belongs_to :user
@@ -88,28 +92,19 @@ super_module :UserIdentifiable do
   end
 end
 ```
-Using `super_module`, developers can directly add class method invocations and definitions inside the module's body, and [`SuperModule`](https://github.com/AndyObtiva/super_module) takes care of automatically mixing them into classes that include the module.
+By including `SuperModule` (following Ruby's basic convention of relying on a module), developers can directly add class method invocations and definitions inside the module's body, and [`SuperModule`](https://github.com/AndyObtiva/super_module) takes care of automatically mixing them into classes that include the module.
 
 As a result, [SuperModule](https://rubygems.org/gems/super_module) collapses the difference between extending a super class and including a super module, thus encouraging developers to write simpler code while making better Object-Oriented Design decisions.
 
 In other words, [SuperModule](https://rubygems.org/gems/super_module) furthers Ruby's goal of making programmers happy.
 
-By the way, SuperModule 2 Beta supports an alternate syntax as well:
-
-```ruby
-UserIdentifiable = super_module do
-end
-```
-
-
-
 ## Instructions
 
 #### 1) Install and require gem
 
 <b>Using [Bundler](http://bundler.io/)</b>
 
-Add the following to Gemfile: <pre>gem 'super_module', '1.2.2'</pre>
+Add the following to Gemfile: <pre>gem 'super_module', '1.3.0'</pre>
 
 And run the following command: <pre>bundle</pre>
 
@@ -123,10 +118,11 @@ Run the following command: <pre>gem install super_module</pre>
 
 Add the following at the top of your [Ruby](https://www.ruby-lang.org/en/) file: <pre>require 'super_module'</pre>
 
-#### 2) Call `super_module(name)` and pass it the super module body in a block
+#### 2) Simply include SuperModule in your module (just like you would do any other Ruby module)
 
 ```ruby
-super_module :UserIdentifiable do
+module UserIdentifiable
+  include SuperModule
   include ActiveModel::Model
 
   belongs_to :user
@@ -151,7 +147,8 @@ end
 class CourseEnrollment < ActiveRecord::Base
   include UserIdentifiable
 end
-super_module :Accountable do
+module Accountable
+  include SuperModule
   include UserIdentifiable
 end
 class Activity < ActiveRecord::Base
@@ -194,7 +191,8 @@ Create a ruby file called super_module_irb_example.rb with the following content
 require 'rubygems' # to be backwards compatible with Ruby 1.8.7
 require 'super_module'
 
-super_module :RequiresAttributes do
+module RequiresAttributes
+  include SuperModule
 
   def self.requires(*attributes)
     attributes.each {|attribute| required_attributes << attribute}
@@ -267,58 +265,35 @@ V2 has a much simpler algorithm than V1 that goes as follows:
 3. Assign the cloned `SuperModule` to a new constant as defined by name (e.g. 'Utilities::Printer') under a class, module, or the top-level Ruby scope
 4. When calling `include` on the module later on, its stored super_module_body attribute is retrieved and run in the including class or module body via `class_eval`
 
-## Limitations and Caveats
+## Warnings
+
+1) [SuperModule](https://rubygems.org/gems/super_module) by definition has been designed to be used only in the initial code declaration of a module, not later mixing or re-opening of a module.
 
- * [SuperModule](https://rubygems.org/gems/super_module) has been designed to be used only in the initial code definition of a module (not supporting later re-opening of the module.)
+2) Given [SuperModule](https://rubygems.org/gems/super_module)'s implementation relies on `self.included(base)`, sub-modules must not hook into it.
 
- * Given [SuperModule](https://rubygems.org/gems/super_module)'s implementation relies on `self.included(base)`, if an including super module (or a super module including another super module) must hook into <code>self.included(base)</code> for meta-programming cases that require it, such as conditional `include` statements or method definitions, it would have to alias <code>self.included(base)</code> and then invoke the aliased version in every super module that needs it like in this example:
+In very rare occasions when an including module needs to redefine <code>self.included(base)</code> for meta-programming purposes, you may do so at your own peril by first invoking <code>self.included_super_module(base)</code> like in this example:
 ```ruby
-super_module :AdminIdentifiable do
+module AdminIdentifiable
+    include SuperModule
     include UserIdentifiable
 
     class << self
-        alias included_super_module included
         def included(base)
             included_super_module(base)
-            # do some extra work
+            # do some extra rare meta-programming work
             # like conditional inclusion of other modules
             # or conditional definition of methods
         end
     end
 end
 ```
-In the future, [SuperModule](https://rubygems.org/gems/super_module) could perhaps provide robust built-in facilities for allowing super modules to easily hook into <code>self.included(base)</code> without interfering with [SuperModule](https://rubygems.org/gems/super_module) behavior.
+This does not work for all cases (like multiple levels of super module nesting), and is not recommended, likely causing problems.
 
-## What's New?
+Avoid hooking into `self.included(base)` at all costs.
 
-### v2 Beta (v1.2.2)
+## Change Log
 
-* Relaxed dependency on `method_source` gem version
-
-### v2 Beta (v1.2.1)
-
-* Standalone super module usage (e.g. direct class method invocation)
-
-### v2 Beta (v1.2.0)
-
-* New `super_module(name)` syntax
-* Much simpler implementation with guaranteed correctness and no performance hit
-* Less memory footprint by not requiring method_source Ruby gem for v2 syntax
-* Backwards compatibility with v1 syntax
-
-### v1.1.1
-
-* Added support for private and protected methods
-* Added many more RSpec test cases, including testing of empty and comment containing singleton methods
-
-### v1.1.0
-
- * Brand new `self`-friendly algorithm that ensures true mixing of super module singleton methods into the including base class or module, thus always returning the actual base class or module `self` when invoking a super module inherited singleton method (thanks to [Banister](https://github.com/banister) for [reporting previous limitation on Reddit and providing suggestions](http://www.reddit.com/r/ruby/comments/30j66y/step_aside_activesupportconcern_supermodule_is/))
- * New `included_super_modules` inherited singleton method that provides developer with a list of all included super modules similar to the Ruby `included_modules` method.
- * No more use for method_missing (Thanks to Marc-André Lafortune for bringing up as a previous limitation in [AirPair article reviews](https://www.airpair.com/ruby/posts/step-aside-activesupportconcern-supermodule-is-the-new-sheriff-in-town))
- * New dependency on [Banister](https://github.com/banister)'s [method_source](https://github.com/banister/method_source) library to have the self-friendly algorithm eval inherited class method sources into the including base class or module.
- * Refactorings, including break-up of the original SuperModule into 3 modules in separate files
- * More RSpec test coverage, including additional method definition scenarios, such as when adding dynamically via `class_eval` and `define_method`
+[CHANGELOG.md](https://raw.githubusercontent.com/AndyObtiva/super_module/master/CHANGELOG.md)
 
 ## Feedback and Contribution
 
@@ -332,6 +307,11 @@ The library is quite new and can use all the feedback and help it can get. So, p
  * 2015-03-27 - [AirPair](http://www.airpair.com) Article: [Step aside ActiveSupport::Concern. SuperModule is the new sheriff in town!](https://www.airpair.com/ruby/posts/step-aside-activesupportconcern-supermodule-is-the-new-sheriff-in-town)
  * 2014-03-27 - [Code Painter](http://andymaleh.blogspot.com) Blog Post: [Ruby SuperModule Comes To The Rescue!!](http://andymaleh.blogspot.ca/2014/03/ruby-supermodule-comes-to-rescue.html)
 
+## TODO
+
+- Fix issue where class methods cannot get called from super_module directly (when used with "CONSTANT = super_module do" approach)
+- Fix issue where a super module (declared with super_module) can get included in one class only where class methods work, but the next class that includes the super module does not have class methods work
+
 ## Copyright
 
 Copyright (c) 2014-2016 Andy Maleh. See LICENSE.txt for

data/VERSION

@@ -1 +1 @@
-1.2.2
+1.3.0

data/lib/super_module.rb

@@ -8,50 +8,12 @@
 
 # Avoiding require_relative for backwards compatibility with Ruby 1.8.7
 
+require_relative 'super_module/v1'
+
 module SuperModule
   class << self
-    V1_LIBRARY = File.expand_path(File.join(File.dirname(__FILE__), 'super_module', 'v1'))
-  
-    attr_accessor :super_module_body
-
-    def define(&super_module_body)
-      clone.tap { |super_module| super_module.super_module_body = super_module_body }
-    end
-
     def included(original_base)
-      if super_module_body
-        original_base.class_eval(&super_module_body)
-      else
-        require V1_LIBRARY
-        original_base.send(:include, SuperModule::V1)
-      end
-    end
-
-    def __super_module_parent(name, ancestor)
-      name_tokens = name.to_s.split('::')
-      name_token_count = name_tokens.size
-      if name_token_count == 1
-        ancestor
-      else
-        top_ancestor = ancestor.const_get(name_tokens.first)
-        sub_module_name = name_tokens[1, name_token_count].join('::')
-        __super_module_parent(sub_module_name, top_ancestor)
-      end
-    end
-
-  end
-  
-end
-
-def super_module(name=nil, &super_module_body)
-  initial_ancestor = self.class == Object ? Object : self
-  SuperModule.define(&super_module_body).tap do |new_super_module|
-    if name
-      parent = SuperModule.__super_module_parent(name, initial_ancestor)
-      module_name = name.to_s.split('::').last
-      parent.const_set(module_name, new_super_module)
-      super_module_body = new_super_module.super_module_body
-      new_super_module.class_eval(&super_module_body)
+      original_base.send(:include, SuperModule::V1)
     end
   end
 end

data/lib/super_module/v1.rb

@@ -28,10 +28,10 @@ module SuperModule
               __define_super_module_singleton_methods(base)
               __invoke_module_body_method_calls(base)
             end
+            alias included_super_module included
           end
         end
       end
     end
   end
 end
-

data/lib/super_module/v1/singleton_method_definition_store.rb

@@ -26,7 +26,8 @@ module SuperModule
           :dbg_print, #debugger library friendly exclusion
           :dbg_puts, #debugger library friendly exclusion
           :define,
-          :included, 
+          :included,
+          :included_super_module,
           :included_super_modules,
           :singleton_method_added,
           :super_module_body
@@ -36,7 +37,7 @@ module SuperModule
       def __super_module_singleton_methods
         @__super_module_singleton_methods ||= []
       end
-      
+
       def __singleton_method_body_for(super_module, method_name)
         super_module.__super_module_singleton_methods.detect {|sm_method_name, sm_method_body| sm_method_name == method_name}[1]
       end
@@ -78,7 +79,7 @@ module SuperModule
 
       def __singleton_method_body(method_name)
           super_module_having_method = __super_module_having_method(method_name)
-          super_module_having_method ? __singleton_method_body_for(super_module_having_method, method_name) : __build_singleton_method_body_source(method_name) 
+          super_module_having_method ? __singleton_method_body_for(super_module_having_method, method_name) : __build_singleton_method_body_source(method_name)
       end
 
       def __overwrite_singleton_method_from_current_super_module(method_name, method_body)
@@ -91,7 +92,7 @@ module SuperModule
       def singleton_method_added(method_name)
         unless __super_module_singleton_methods_excluded_from_base_definition.include?(method_name)
           method_body = __singleton_method_body(method_name)
-          __super_module_singleton_methods << [method_name, method_body] 
+          __super_module_singleton_methods << [method_name, method_body]
           __overwrite_singleton_method_from_current_super_module(method_name, method_body)
         end
       end

data/spec/lib/super_module_spec.rb

@@ -1,219 +1,256 @@
 require 'spec_helper'
 
-describe SuperModule do
+class V1::FakeActiveRecord
+  include ::V1::FakeActiveModel
+end
 
-  ['V1',
-   'V2',
-   'V2Alt'
-  ].each do |version|
-    Object.send(:remove_const, :SupportVersion) rescue nil
-    SupportVersion = Support.const_get(version)
-    
-    Object.send(:remove_const, :FakeActiveRecord) rescue nil
-    class FakeActiveRecord
-      include SupportVersion::FakeActiveModel
-    end
+class V1::FooActiveRecord < V1::FakeActiveRecord
+  include ::V1::Foo
+end
 
-    Object.send(:remove_const, :FooActiveRecord) rescue nil
-    class FooActiveRecord < FakeActiveRecord
-      include SupportVersion::Foo
-    end
+class V1::BarActiveRecord < V1::FakeActiveRecord
+  include ::V1::Bar
+end
+
+class V1::BazActiveRecord < V1::FakeActiveRecord
+  include ::V1::Baz
+end
+
+module V1::SummarizedActiveModel
+  include SuperModule
 
-    Object.send(:remove_const, :BarActiveRecord) rescue nil
-    class BarActiveRecord < FakeActiveRecord
-      include SupportVersion::Bar
+  def self.included(klass)
+    included_super_module(klass)
+    if klass.name.split(/::/).last.start_with?('Fake')
+      klass.extend(FakeClassMethods)
     end
+  end
+  
+  def self.validates(attribute, options)
+    super # test that singleton class inheritance works
+  end
+
+  def self.validations
+    super # test that singleton class inheritance works
+  end
+
+  def self.summary
+    validations.flatten.map(&:to_s).join("/")
+  end
 
-    Object.send(:remove_const, :BazActiveRecord) rescue nil
-    class BazActiveRecord < FakeActiveRecord
-      include SupportVersion::Baz
+  module FakeClassMethods
+    def fake_summary
+      'This is a fake summary.'
     end
+  end
+end
 
-    context version do
+class V1::SummarizedActiveRecord < V1::FakeActiveRecord
+  include ::V1::SummarizedActiveModel
+end
 
-      context "standalone module usage" do
-        subject { Support::V2::FakeActiveModel }
+class V1::FakeSummarizedActiveRecord < V1::FakeActiveRecord
+  include ::V1::SummarizedActiveModel
+end
 
-        it 'allows invoking class methods' do
-          subject.validates 'foo', {:presence => true}
-          expect(subject.validations).to include(['foo', {:presence => true}])
-        end
+describe SuperModule do
+  context V1 do
+    context "standalone module usage" do
+      subject { V1::FakeActiveModel }
 
+      it 'allows invoking class methods' do
+        subject.validates 'foo', {:presence => true}
+        expect(subject.validations).to include(['foo', {:presence => true}])
       end
+    end
 
-      context "included by a module (Foo) that is included by a class (FooActiveRecord)" do
+    context "included by a module (Foo) that is included by a class (FooActiveRecord)" do
 
-        subject { FooActiveRecord }
+      subject { V1::FooActiveRecord }
 
-        it 'allows invoking class methods' do
-          expect(subject.validations).to include(['foo', {:presence => true}])
-        end
+      it 'allows invoking class methods' do
+        expect(subject.validations).to include(['foo', {:presence => true}])
+      end
 
-        it 'includes class method declared via "self.method_name"' do
-          expect(subject.foo).to eq('self.foo')
-        end
+      it 'includes class method declared via "self.method_name"' do
+        expect(subject.foo).to eq('self.foo')
+      end
 
-        it 'includes class method declared via "self.method_name" taking a single parameter' do
-          expect(subject.foo_single_param('param1_value')).to eq('self.foo(param1_value)')
-        end
+      it 'includes class method declared via "self.method_name" taking a single parameter' do
+        expect(subject.foo_single_param('param1_value')).to eq('self.foo(param1_value)')
+      end
 
-        it 'includes class method declared via "self.method_name" taking multiple parameters' do
-          expect(subject.foo_multi_params('param1_value', 'param2_value', 'param3_value')).to eq('self.foo(param1_value,param2_value,param3_value)')
-        end
+      it 'includes class method declared via "self.method_name" taking multiple parameters' do
+        expect(subject.foo_multi_params('param1_value', 'param2_value', 'param3_value')).to eq('self.foo(param1_value,param2_value,param3_value)')
+      end
 
-        it 'includes class method declared via "self.method_name" taking a block' do
-          formatter = Proc.new {|value| "Block formatted #{value}"}
-          expect(subject.foo_block(&formatter)).to eq('Block formatted self.foo')
-        end
+      it 'includes class method declared via "self.method_name" taking a block' do
+        formatter = Proc.new {|value| "Block formatted #{value}"}
+        expect(subject.foo_block(&formatter)).to eq('Block formatted self.foo')
+      end
 
-        it 'includes class method declared via "self.method_name" taking a single paramter and a block' do
-          formatter = Proc.new {|value, param1| "Block formatted #{value} with #{param1}"}
-          expect(subject.foo_single_param_block('param1_value', &formatter)).to eq('Block formatted self.foo with param1_value')
-        end
+      it 'includes class method declared via "self.method_name" taking a single paramter and a block' do
+        formatter = Proc.new {|value, param1| "Block formatted #{value} with #{param1}"}
+        expect(subject.foo_single_param_block('param1_value', &formatter)).to eq('Block formatted self.foo with param1_value')
+      end
 
-        it 'includes class method declared via "self.method_name" taking multiple paramters and a block' do
-          formatter = Proc.new {|value, param1, param2, param3| "Block formatted #{value} with #{param1},#{param2},#{param3}"}
-          expect(subject.foo_multi_params_block('param1_value', 'param2_value', 'param3_value', &formatter)).to eq('Block formatted self.foo with param1_value,param2_value,param3_value')
-        end
+      it 'includes class method declared via "self.method_name" taking multiple paramters and a block' do
+        formatter = Proc.new {|value, param1, param2, param3| "Block formatted #{value} with #{param1},#{param2},#{param3}"}
+        expect(subject.foo_multi_params_block('param1_value', 'param2_value', 'param3_value', &formatter)).to eq('Block formatted self.foo with param1_value,param2_value,param3_value')
+      end
 
-        it 'includes class method declared via "self.method_name" on one line' do
-          expect(subject.foo_one_line).to eq('self.foo_one_line')
-        end
+      it 'includes class method declared via "self.method_name" on one line' do
+        expect(subject.foo_one_line).to eq('self.foo_one_line')
+      end
 
-        it 'includes class method declared via "class < self"' do
-          expect(subject.foo_class_self).to eq('self.foo_class_self')
-        end
+      it 'includes class method declared via "class < self"' do
+        expect(subject.foo_class_self).to eq('self.foo_class_self')
+      end
 
-        it 'includes class method declared via "class < self" using define_method' do
-          expect(subject.foo_class_self_define_method).to eq('self.foo_class_self_define_method')
-        end
+      it 'includes class method declared via "class < self" using define_method' do
+        expect(subject.foo_class_self_define_method).to eq('self.foo_class_self_define_method')
+      end
 
-        it 'includes private class method' do
-          expect{subject.foo_private}.to raise_error
-          expect(subject.private_methods.map(&:to_s)).to include('foo_private')
-          expect(subject.send(:foo_private)).to eq('self.foo_private')
-        end
+      it 'includes private class method' do
+        expect{subject.foo_private}.to raise_error
+        expect(subject.private_methods.map(&:to_s)).to include('foo_private')
+        expect(subject.send(:foo_private)).to eq('self.foo_private')
+      end
 
-        it 'includes protected class method (declared using protected :method_name)' do
-          expect{subject.foo_protected}.to raise_error
-          expect(subject.protected_methods.map(&:to_s)).to include('foo_protected')
-          expect(subject.send(:foo_protected)).to eq('self.foo_protected')
-        end
+      it 'includes protected class method (declared using protected :method_name)' do
+        expect{subject.foo_protected}.to raise_error
+        expect(subject.protected_methods.map(&:to_s)).to include('foo_protected')
+        expect(subject.send(:foo_protected)).to eq('self.foo_protected')
+      end
 
-        it 'includes empty class method' do
-          expect(subject.empty).to eq(nil)
-        end
+      it 'includes empty class method' do
+        expect(subject.empty).to eq(nil)
+      end
 
-        it 'includes empty class method with one empty line' do
-          expect(subject.empty_one_empty_line).to eq(nil)
-        end
+      it 'includes empty class method with one empty line' do
+        expect(subject.empty_one_empty_line).to eq(nil)
+      end
 
-        it 'includes empty class method with comment' do
-          expect(subject.empty_with_comment).to eq(nil)
-        end
+      it 'includes empty class method with comment' do
+        expect(subject.empty_with_comment).to eq(nil)
+      end
 
-        it 'includes empty class method one line definition' do
-          expect(subject.empty_one_line_definition).to eq(nil)
-        end
+      it 'includes empty class method one line definition' do
+        expect(subject.empty_one_line_definition).to eq(nil)
+      end
 
-        it 'includes empty class method one line definition with spaces' do
-          expect(subject.empty_one_line_definition_with_spaces).to eq(nil)
-        end
+      it 'includes empty class method one line definition with spaces' do
+        expect(subject.empty_one_line_definition_with_spaces).to eq(nil)
+      end
 
-        it 'includes instance methods' do
-          instance = subject.new
+      it 'includes instance methods' do
+        instance = subject.new
 
-          expect(instance.foo).to eq('foo')
-        end
+        expect(instance.foo).to eq('foo')
+      end
 
-        it 'provides class method self as the including base class as in the class method (meh)' do
-          expect(subject.meh).to eq(subject)
-        end
+      it 'provides class method self as the including base class as in the class method (meh)' do
+        expect(subject.meh).to eq(subject)
       end
+    end
 
-      context "included by a module (Foo) that is included by a second module (Bar) that is included by a class (BarActiveRecord)" do
+    context "included by a module (Foo) that is included by a second module (Bar) that is included by a class (BarActiveRecord)" do
 
-        subject { BarActiveRecord }
+      subject { V1::BarActiveRecord }
 
-        it 'allows invoking class methods' do
-          expect(subject.validations).to include(['foo', {:presence => true}])
-          expect(subject.validations).to include(['bar', {:presence => true}])
-        end
+      it 'allows invoking class methods' do
+        expect(subject.validations).to include(['foo', {:presence => true}])
+        expect(subject.validations).to include(['bar', {:presence => true}])
+      end
 
-        it 'includes class methods declared via "class << self"' do
-          expect(subject.foo).to eq('self.foo')
-          expect(subject.bar).to eq('self.bar')
-        end
+      it 'includes class methods declared via "class << self"' do
+        expect(subject.foo).to eq('self.foo')
+        expect(subject.bar).to eq('self.bar')
+      end
 
-        it 'includes instance methods' do
-          instance = subject.new
+      it 'includes instance methods' do
+        instance = subject.new
 
-          expect(instance.foo).to eq('foo')
-          expect(instance.bar).to eq('bar')
-        end
+        expect(instance.foo).to eq('foo')
+        expect(instance.bar).to eq('bar')
+      end
 
-        it 'can include a basic module (Forwardable) into singleton class by placing in class << self' do 
-          instance = subject.new
-          expect(instance.length).to eq(3)
-        end
+      it 'can include a basic module (Forwardable) into singleton class by placing in class << self' do
+        instance = subject.new
+        expect(instance.length).to eq(3)
+      end
 
-        it 'applies super module (Bar) class method invocation (make_barrable) on including class (BarActiveRecord), whereby the method that is defined in the same super module that declares it (Bar)' do
-          expect(subject.barrable).to eq(true)
-        end
+      it 'applies super module (Bar) class method invocation (make_barrable) on including class (BarActiveRecord), whereby the method that is defined in the same super module that declares it (Bar)' do
+        expect(subject.barrable).to eq(true)
+      end
 
-        it 'can include a basic module (Comparable)' do 
-          now = Time.now
-          allow(Time).to receive(:now).and_return(now)
-          instance = subject.new
-          allow(Time).to receive(:now).and_return(now + 100)
-          instance2 = subject.new
+      it 'can include a basic module (Comparable)' do
+        now = Time.now
+        allow(Time).to receive(:now).and_return(now)
+        instance = subject.new
+        allow(Time).to receive(:now).and_return(now + 100)
+        instance2 = subject.new
 
-          expect(instance2 > instance).to eq(true)
-        end
+        expect(instance2 > instance).to eq(true)
+      end
 
-        it 'provides class method self as the including base class as in the class method (meh)' do
-          expect(subject.meh).to eq(subject)
-        end
+      it 'provides class method self as the including base class as in the class method (meh)' do
+        expect(subject.meh).to eq(subject)
       end
+    end
+
+    context "(with SuperModule.define alternate syntax in Baz) included by a module (Foo), included by another module (Bar), included by a third module (Baz) that is included by a class (BazActiveRecord)" do
 
-      context "(with SuperModule.define alternate syntax in Baz) included by a module (Foo), included by another module (Bar), included by a third module (Baz) that is included by a class (BazActiveRecord)" do
+      subject { V1::BazActiveRecord }
 
-        subject { BazActiveRecord }
+      it 'allows invoking class methods' do
+        expect(subject.validations).to include(['foo', {:presence => true}])
+        expect(subject.validations).to include(['bar', {:presence => true}])
+        expect(subject.validations).to include(['baz', {:presence => true}])
+      end
 
-        it 'allows invoking class methods' do
-          expect(subject.validations).to include(['foo', {:presence => true}])
-          expect(subject.validations).to include(['bar', {:presence => true}])
-          expect(subject.validations).to include(['baz', {:presence => true}])
-        end
+      it 'includes class methods declared via "class << self"' do
+        expect(subject.foo).to eq('self.foo')
+        expect(subject.bar).to eq('self.bar')
+        expect(subject.baz).to eq('self.baz')
+      end
 
-        it 'includes class methods declared via "class << self"' do
-          expect(subject.foo).to eq('self.foo')
-          expect(subject.bar).to eq('self.bar')
-          expect(subject.baz).to eq('self.baz')
-        end
+      it 'includes instance methods' do
+        instance = subject.new(100)
 
-        it 'includes instance methods' do
-          instance = BazActiveRecord.new(100)
+        expect(instance.foo).to eq('foo')
+        expect(instance.bar).to eq('bar')
+        expect(instance.baz).to eq('baz')
+      end
 
-          expect(instance.foo).to eq('foo')
-          expect(instance.bar).to eq('bar')
-          expect(instance.baz).to eq('baz')
-        end
+      it 'invokes singleton method (make_barrable) from super module' do
+        expect(subject.barrable).to eq(true)
+      end
 
-        it 'invokes singleton method (make_barrable) from super module' do
-          expect(subject.barrable).to eq(true)
-        end
+      it 'can override super module behavior (<=>)' do
+        instance = subject.new(50)
+        instance2 = subject.new(7)
 
-        it 'can override super module behavior (<=>)' do 
-          instance = subject.new(50)
-          instance2 = subject.new(7)
+        expect(instance2 > instance).to eq(false)
+      end
 
-          expect(instance2 > instance).to eq(false)
-        end
+      it 'provides class method self as the including base class as in the class method (meh)' do
+        expect(subject.meh).to eq(subject)
+      end
+    end
 
-        it 'provides class method self as the including base class as in the class method (meh)' do
-          expect(subject.meh).to eq(subject)
-        end
+    context 'meta-programming included' do
+      it 'returns summary' do
+        V1::SummarizedActiveRecord.validates 'foo', {:presence => true}
+        V1::SummarizedActiveRecord.validates 'bar', {:presence => true}
+        expect(V1::SummarizedActiveRecord.summary).to eq('foo/{:presence=>true}/bar/{:presence=>true}')
+        expect{V1::SummarizedActiveRecord.fake_summary}.to raise_error
+      end
+      it 'returns fake summary' do
+        V1::FakeSummarizedActiveRecord.validates 'foo', {:presence => true}
+        V1::FakeSummarizedActiveRecord.validates 'bar', {:presence => true}
+        expect(V1::FakeSummarizedActiveRecord.summary).to eq('foo/{:presence=>true}/bar/{:presence=>true}')
+        expect(V1::FakeSummarizedActiveRecord.fake_summary).to eq('This is a fake summary.')
       end
     end
   end