super_module 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ed999facd85a8593e0e0af6a036c625a68f51ae
-  data.tar.gz: 27219be2a1966b18e253d839b76232e118d27824
+  metadata.gz: 9bd0e7f146de1366ca97c760ab283ca3f3623c44
+  data.tar.gz: ce3dad2bf81e80135bfaaea2fbdf2e305359e8b6
 SHA512:
-  metadata.gz: 6bb3130d30bb2bf2baf04c657a828020375f2b3bb0a5504cae2d8da924ba5184deee3aace7cc4f2359c4bb8f85cc603189734e27fecdee6461b75fb873a4144c
-  data.tar.gz: bc3d4b819dbd682c75c8a26b5d58da614615f60f14f5e880f6128dcd2ab15feb947b571d79aed3f95a7907c3ab7fbe68d71a71f398ca72836f638ba011de5ab8
+  metadata.gz: 6f28bdb35c1cf93c1a0b4a98d3f22726ca95e02e1f95458b1965fa2d097f6497da7c2359ae6dcb656db49c0443f5f8fe0c1f270efffee6a5ee0da91571247547
+  data.tar.gz: d698ce744051e84c772eb32c38fed978e8b4711e846012a2c6cd8b3cc3058f8a95de27f2a28b01cdb7ca3ef01f44c5f249f282086d6187830adfbff7a6e96c8b

data/README.md

@@ -1,17 +1,14 @@
-# SuperModule
-[![Gem Version](https://badge.fury.io/rb/super_module.png)](http://badge.fury.io/rb/super_module)
-[![Build Status](https://api.travis-ci.org/AndyObtiva/super_module.png?branch=master)](https://travis-ci.org/AndyObtiva/super_module)
-[![Coverage Status](https://coveralls.io/repos/AndyObtiva/super_module/badge.png?branch=master)](https://coveralls.io/r/AndyObtiva/super_module?branch=master)
-[![Code Climate](https://codeclimate.com/github/AndyObtiva/super_module.png)](https://codeclimate.com/github/AndyObtiva/super_module)
+# <img src="https://raw.githubusercontent.com/AndyObtiva/super_module/master/SuperModule.jpg" alt="SuperModule" align="left" height="50" /> &nbsp; SuperModule v1.1.1 [2015-04-09]
+[![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)
 
-Tired of [Ruby](https://www.ruby-lang.org/en/)'s modules not allowing you to mix in class methods easily?
-Tired of writing complex `self.included(base)` code or using over-engineered solutions like [`ActiveSupport::Concern`](http://api.rubyonrails.org/classes/ActiveSupport/Concern.html) to accomplish that goal?
+Calling [Ruby](https://www.ruby-lang.org/en/)'s [`Module#include`](http://ruby-doc.org/core-2.2.1/Module.html#method-i-include) to mix in a module does not bring in class methods by default. This can come as quite a surprise whenever a developer attempts to include class methods via a module. Fortunately, Ruby does offer a solution in the form of implementing the hook method [`Module.included(base)`](http://ruby-doc.org/core-2.2.1/Module.html#method-i-included) [following a certain boilerplate code idiom](http://www.railstips.org/blog/archives/2009/05/15/include-vs-extend-in-ruby/). However, this solution can hinder code maintainability and productivity flow in a big production-environment project that takes advantage of many [mixins](http://en.wikipedia.org/wiki/Mixin) to model the business domain via composable object [traits](http://en.wikipedia.org/wiki/Trait_(computer_programming)). 
 
-Well, worry no more! [SuperModule](https://rubygems.org/gems/super_module) comes to the rescue!
+[`ActiveSupport::Concern`](http://api.rubyonrails.org/classes/ActiveSupport/Concern.html) is a popular 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 improves the readability of the code needed to include class methods, it supports the same boilerplate idiom, thus feeling no more than putting a band-aid on the problem.
 
-[SuperModule](https://rubygems.org/gems/super_module) allows defining class methods and method invocations the same way a super class does without using [`self.included(base)`](http://ruby-doc.org/core-2.2.1/Module.html#method-i-included).
-
-This succeeds [`ActiveSupport::Concern`](http://api.rubyonrails.org/classes/ActiveSupport/Concern.html) by offering lighter syntax and simpler module dependency support.
+Fortunately, [SuperModule](https://rubygems.org/gems/super_module) comes to the rescue. Including `SuperModule` at the top of a Ruby module's body automatically ensures inclusion of class methods whenever a developer mixes it in via [`Module#include`](http://ruby-doc.org/core-2.2.1/Module.html#method-i-include).
 
 ## Introductory Comparison
 
@@ -170,7 +167,8 @@ CourseEnrollment.new(course_id: course.id).valid?
 
  * SuperModule: name of the library and Ruby module that provides functionality via mixin
  * Super module: any Ruby module that mixes in SuperModule
- * Class method definition: Ruby class or module method declared with <code>self.method_name</code> or <code>class << self</code>
+ * Singleton class: also known as the [metaclass](https://rubymonk.com/learning/books/4-ruby-primer-ascent/chapters/39-ruby-s-object-model/lessons/131-singleton-methods-and-metaclasses) or [eigenclass](http://eigenjoy.com/2008/05/29/railsconf08-meta-programming-ruby-for-fun-and-profit/), it is the object-instance-associated class copy available to every object in Ruby (e.g. every `Object.new` instance has a singleton class that is a copy of the `Object` class, which can house instance-specific behavior if needed)
+ * Singleton method: an instance method defined on an object's singleton class. Often used to refer to a class or module method defined on the [Ruby class object or module object singleton class](http://ruby-doc.com/docs/ProgrammingRuby/html/classes.html) via `def self.method_name(...)` or `class << self` enclosing `def method_name(...)`
  * Class method invocation: Inherited Ruby class or module method invoked in the body of a class or module (e.g. <code>validates :username, presence: true</code>)
  * Code-time: Time of writing code in a Ruby file as opposed to Run-time
  * Run-time: Time of executing Ruby code
@@ -182,78 +180,78 @@ CourseEnrollment.new(course_id: course.id).valid?
  * A super module can only be included in a class or another super module
  * SuperModule adds <b>zero cost</b> to instantiation of including classes and invocation of included methods (both class and instance)
 
-## Another Example
+## IRB Example
 
-Copy and paste the following code snippets in <code>irb</code> and you should get the output denoted by double arrows (<code>=></code>).
+Create a ruby file called super_module_irb_example.rb with the following content:
 
 ```ruby
+require 'rubygems' # to be backwards compatible with Ruby 1.8.7
 require 'super_module'
 
-module Foo
+module RequiresAttributes
   include SuperModule
 
-  validates :credit_card_id, presence: true
-
-  def foo
-    puts 'foo'
-    'foo'
+  def self.requires(*attributes)
+    attributes.each {|attribute| required_attributes << attribute}
   end
 
-  def self.foo
-    puts 'self.foo'
-    'self.foo'
-  end
-end
-
-module Bar
-  include SuperModule
-  include Foo
-
-  validates :user_id, presence: true
-
-  def bar
-    puts 'bar'
-    'bar'
+  def self.required_attributes
+    @required_attributes ||= []
   end
-
-  def self.bar
-    puts 'self.bar'
-    'self.bar'
+  
+  def requirements_satisfied?
+    !!self.class.required_attributes.reduce(true) { |result, required_attribute| result && send(required_attribute) }
   end
 end
 
-class MediaAuthorization < ActiveRecord::Base
-  include Bar
+class MediaAuthorization
+  include RequiresAttributes
+  attr_accessor :user_id, :credit_card_id
+  requires :user_id, :credit_card_id
 end
-
-MediaAuthorization.create.errors.messages.inspect
 ```
 
-=> "{:credit_card_id=>[\"can't be blank\"], :user_id=>[\"can't be blank\"]}"
+Open `irb` ([Interactive Ruby](https://www.ruby-lang.org/en/documentation/quickstart/)) and paste the following code snippets in. You should get the output denoted by the rockets (`=>`).
 
 ```ruby
-MediaAuthorization.new.foo
+require './super_module_irb_example.rb'
 ```
+=> true
 
-=> "foo"
+```ruby
+MediaAuthorization.required_attributes
+```
+=> [:user_id, :credit_card_id]
 
 ```ruby
-MediaAuthorization.new.bar
+media_authorization = MediaAuthorization.new # resulting object print-out varies
 ```
+=> #<MediaAuthorization:0x832b36be1>
 
-=> "bar"
+```ruby
+media_authorization.requirements_satisfied?
+```
+=> false
 
 ```ruby
-MediaAuthorization.foo
+media_authorization.user_id = 387
 ```
+=> 387
 
-=> "self.foo"
+```ruby
+media_authorization.requirements_satisfied?
+```
+=> false
 
 ```ruby
-MediaAuthorization.bar
+media_authorization.credit_card_id = 37
 ```
+=> 37
 
-=> "self.bar"
+```ruby
+media_authorization.requirements_satisfied?
+```
+=> true
 
 ## How Does It Work?
 
@@ -261,68 +259,70 @@ Here is the general algorithm from the implementation:
 
 ```ruby
 def included(base)
-  __invoke_super_module_class_method_calls(base)
   __define_super_module_class_methods(base)
+  __invoke_super_module_class_method_calls(base)
 end
 ```
 
-#### 1) Invoke super module class method calls on the including base class.
+#### 1) Defines super module class methods on the including base class
 
-For example, suppose we have a super module called `Locatable`:
+For example, suppose we have a super module called Addressable:
 
 ```ruby
-module Locatable
+module Addressable
   include SuperModule
   
-  validates :x_coordinate, numericality: true
-  validates :y_coordinate, numericality: true
-  
-  def move(x, y)
-    self.x_coordinate += x
-    self.y_coordinate += y
+  include Locatable
+  validates :city, presence: true, length: { maximum: 255 }
+  validates :state, presence: true, length: { is: 2 }
+
+  def self.merge_duplicates
+    # 1. Look through all Addressable instances in the database
+    # 2. Identify duplicates
+    # 3. Merge duplicate addressables
   end
 end
 
-class Vehicle < ActiveRecord::Base
-  include Locatable
+class Contact < ActiveRecord::Base
+  include Addressable
 # … more code follows
 end
 ```
 
-This first step guarantees invocation of the two `Locatable` <code>validates</code> method calls on the `Vehicle` object class.
+This step ensures that <code>merge_duplicates</code> is included in Contact as a class method, allowing the call <code>Contact.merge_duplicates</code>
 
-It does so by relying on `method_missing(method_name, *args, &block)` to record every class method call that happens in the super module class body, and later replaying those calls on the including base class during `self.included(base)` by using Ruby's `send(method_name, *args, &block)` method introspection.
+It does so by recording every class method defined using the Ruby [`self.singleton_method_added(method_name)`](http://ruby-doc.org/core-2.2.1/BasicObject.html#method-i-singleton_method_added) hook, reading class method sources using the [method_source](https://rubygems.org/gems/method_source/) gem, and finally upon invocation of `self.included(base)`, `class_eval`ing the recorded class methods on the including base class (or module).
 
-#### 2) Defines super module class methods on the including base class
+In order to avoid interference with existing class method definitions, there is an exception list for what not to record, such as <code>:included_super_modules, :class_eval, :singleton_method_added</code> and any other "__" prefixed class methods defined in [SuperModule](https://rubygems.org/gems/super_module), such as <code>__super_module_class_method_calls</code>.
 
-For example, suppose we have a super module called Addressable:
+Also, the recorded class method sources are altered to handle recording of method calls as well, which is used in the second step explained next.
+
+#### 2) Invoke super module class method calls on the including base class (or module).
+
+For example, suppose we have a super module called `Locatable`:
 
 ```ruby
-module Addressable
+module Locatable
   include SuperModule
   
-  include Locatable
-  validates :city, presence: true, length: { maximum: 255 }
-  validates :state, presence: true, length: { is: 2 }
-
-  def self.merge_duplicates
-    # 1. Look through all Addressable instances in the database
-    # 2. Identify duplicates
-    # 3. Merge duplicate addressables
+  validates :x_coordinate, numericality: true
+  validates :y_coordinate, numericality: true
+  
+  def move(x, y)
+    self.x_coordinate += x
+    self.y_coordinate += y
   end
 end
 
-class Contact < ActiveRecord::Base
-  include Addressable
+class Vehicle < ActiveRecord::Base
+  include Locatable
 # … more code follows
 end
 ```
 
-The second step ensures that <code>merge_duplicates</code> is included in Contact as a class method, allowing the call <code>Contact.merge_duplicates</code>
+This step guarantees invocation of the two `Locatable` <code>validates</code> method calls on the `Vehicle` object class.
 
-It does so by recording every class method defined using the <code>self.singleton_method_added(method_name)</code> added hook, and then later replaying these class definitions on the including base class during invocation of <code>self.included(base)</code>.
-
-In order to avoid interference with existing class method definitions, there is an exception list for what not to record, such as <code>:included, :method_missing, :singleton_method_added</code> and any other "__" prefixed class methods defined in [SuperModule](https://rubygems.org/gems/super_module), such as <code>__super_module_class_method_calls</code>.
+It does so by relying on an interally defined method `__record_method_call(method_name, *args, &block)` to record every class method call that happens in the super module class body, and later replaying those calls on the including base class during `self.included(base)` by using Ruby's `send(method_name, *args, &block)` method introspection.
 
 ## Limitations and Caveats
 
@@ -330,7 +330,7 @@ In order to avoid interference with existing class method definitions, there is
 
  * Initial Ruby runtime load of a class or module mixing in [SuperModule](https://rubygems.org/gems/super_module) will incur a very marginal performance hit (in the order of nano-to-milliseconds). However, class usage (instantiation and method invocation) will not incur any performance hit, running as fast as any other Ruby class.
 
- * Given [SuperModule](https://rubygems.org/gems/super_module) relies on <code>self.included(base)</code> in its implementation, 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: 
+ * 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: 
 ```ruby 
 module AdminIdentifiable
     include SuperModule
@@ -348,6 +348,22 @@ module AdminIdentifiable
 ```
 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.
 
+## What's New?
+
+### 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`
+ 
 ## Feedback and Contribution
 
 [SuperModule](https://rubygems.org/gems/super_module) is written in a very clean and maintainable test-first approach, so you are welcome to read through the code on GitHub for more in-depth details:
@@ -355,8 +371,8 @@ https://github.com/AndyObtiva/super_module
 
 The library is quite new and can use all the feedback and help it can get. So, please do not hesitate to add comments if you have any, and please fork [the project on GitHub](https://github.com/AndyObtiva/super_module#fork-destination-box) in order to [make contributions via Pull Requests](https://github.com/AndyObtiva/super_module/pulls).
 
-## Articles and Blog Posts
-
+## Articles, Publications, and Blog Posts
+ * 2015-04-05 - [Ruby Weekly](http://rubyweekly.com): [Issue 240](http://rubyweekly.com/issues/240)
  * 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)
 

data/VERSION

@@ -1 +1 @@
-1.1.0
+1.1.1

data/lib/super_module.rb

@@ -19,7 +19,9 @@ module SuperModule
       class << self
         def __define_super_module_singleton_methods(base)
           __super_module_singleton_methods.each do |method_name, method_body|
-            base.class_eval(method_body)
+            # The following is needed for cases where a method is declared public/protected/private after it was added
+            refreshed_access_level_method_body = method_body.sub(/class << self\n(public|protected|private)\n/, "class << self\n#{__singleton_method_access_level(method_name)}\n")
+            base.class_eval(refreshed_access_level_method_body)
           end
         end
 

data/lib/super_module/singleton_method_definition_store.rb

@@ -42,23 +42,34 @@ module SuperModule
       included_modules.select {|m| m.include?(SuperModule)}
     end
 
+    def __all_methods(object)
+      object.public_methods + object.protected_methods + object.private_methods
+    end
+
     def __super_module_having_method(method_name)
-      included_super_modules.detect {|included_super_module| included_super_module.methods.map(&:to_s).include?(method_name.to_s)}
+      included_super_modules.detect {|included_super_module| __all_methods(included_super_module).map(&:to_s).include?(method_name.to_s)}
     end
 
     def __singleton_method_definition_regex(method_name)
-      /(send)?[ \t(:"']*def(ine_method)?[ \t,:"']+(self\.)?#{method_name}\)?[ \tdo{(|]*([^\n)|;]*)?[ \t)|;]*/m
+      /(public|protected|private)?(send)?[ \t(:"']*def(ine_method)?[ \t,:"']+(self\.)?#{method_name}\)?[ \tdo{(|]*([^\n)|;]*)?[ \t)|;]*/m
     end
 
     def __singleton_method_args(method_name, method_body)
-      method_arg_match = method_body.match(__singleton_method_definition_regex(method_name)).to_a[4]
+      method_arg_match = method_body.match(__singleton_method_definition_regex(method_name)).to_a[5]
+    end
+
+    def __singleton_method_access_level(method_name)
+      %w(private protected public).detect do |method_access|
+        method_group = "#{method_access}_methods"
+        send(method_group).map(&:to_s).include?(method_name.to_s)
+      end
     end
 
     def __build_singleton_method_body_source(method_name)
       method_body = self.method(method_name).source
       method_args = __singleton_method_args(method_name, method_body)
       method_body = "def #{method_name}\n#{method_body}\nend" if method_args.nil?
-      class_self_method_def_enclosure = "class << self\ndefine_method('#{method_name}') do |#{method_args}|\n#{__singleton_method_call_recorder(method_name, method_args)}\n"
+      class_self_method_def_enclosure = "class << self\n#{__singleton_method_access_level(method_name)}\ndef #{method_name}(#{method_args})\n#{__singleton_method_call_recorder(method_name, method_args)}\n"
       method_body.sub(__singleton_method_definition_regex(method_name), class_self_method_def_enclosure) + "\nend\n"
     end
 

data/spec/lib/super_module_spec.rb

@@ -26,10 +26,77 @@ describe SuperModule do
       expect(subject.validations).to include(['foo', {:presence => true}])
     end
 
-    it 'includes class methods declared via "self.method_name"' do
+    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 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 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" 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" 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 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 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 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 instance methods' do
       instance = subject.new
 
@@ -84,11 +151,6 @@ describe SuperModule do
     it 'provides class method self as the including base class as in the class method (meh)' do
       expect(subject.meh).to eq(subject)
     end
-
-         #TODO explicitly declare test cases in support files as it statements
-         #TODO test empty method definition
-         #TODO test empty method definition with comment
-         #TODO test case of method call receiving a block 
   end
 
   context "included by a module (Foo), included by another module (Bar), included by a third module (Baz) that is included by a class (BazActiveRecord)" do

data/spec/support/fake_active_model.rb

@@ -4,11 +4,13 @@ module FakeActiveModel
 
   include SuperModule
 
-  # Defines method on a single line to provide as a test case for SuperModule
-  def self.validates(attribute, options); validations << [attribute, options]; end
+  def self.validates(attribute, options)
+    validations << [attribute, options]
+  end
 
-  # Defines method on a single line to provide as a test case for SuperModule
-  def self.validations; @validations ||= []; end
+  def self.validations
+    @validations ||= []
+  end
 
 end
 

data/spec/support/foo.rb

@@ -4,17 +4,82 @@ module Foo
   include FakeActiveModel
   validates 'foo', {:presence => true}
 
+  class << self
+    def foo_class_self
+      'self.foo_class_self'
+    end
+
+    def foo_class_self_define_method; 'self.foo_class_self_define_method'; end
+
+    def foo_private_declaration_follow_up
+      'self.foo_private_declaration_follow_up'
+    end
+    private :foo_private_declaration_follow_up
+
+    def foo_protected_declaration_follow_up
+      'self.foo_protected_declaration_follow_up'
+    end
+    protected :foo_protected_declaration_follow_up
+
+    private 
+    def foo_private
+      'self.foo_private'
+    end
+  
+    protected
+    def foo_protected
+      'self.foo_protected'
+    end
+
+  end
+
+  def self.meh
+    self
+  end
+
   def self.foo
     'self.foo'
   end
 
-  # Defines singleton method via define_method to provide as a test case for SuperModule
-  class << self
-    send(:define_method, :meh) do
-      self
-    end
+  def self.foo_one_line; 'self.foo_one_line'; end
+
+  def self.foo_single_param(param1)
+    "self.foo(#{param1})"
   end
 
+  def self.foo_multi_params(param1, param2, param3)
+    "self.foo(#{param1},#{param2},#{param3})"
+  end
+
+  def self.foo_block(&formatter)
+    formatter.call('self.foo')
+  end
+
+  def self.foo_single_param_block(param1, &formatter)
+    formatter.call('self.foo', param1)
+  end
+
+  def self.foo_multi_params_block(param1, param2, param3, &formatter)
+    formatter.call('self.foo', param1, param2, param3)
+  end
+
+  public
+
+  def self.empty
+  end
+
+  def self.empty_one_empty_line
+
+  end
+
+  def self.empty_with_comment
+    # no op
+  end
+
+  def self.empty_one_line_definition; end
+
+  def self.empty_one_line_definition_with_spaces;          end
+
   def foo
     'foo'
   end

data/super_module.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: super_module 1.1.0 ruby lib
+# stub: super_module 1.1.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "super_module"
-  s.version = "1.1.0"
+  s.version = "1.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Andy Maleh"]
-  s.date = "2015-04-06"
+  s.date = "2015-04-09"
   s.description = "SuperModule allows defining class methods and method invocations the same way a super class does without using def included(base). This also succeeds ActiveSupport::Concern by offering lighter syntax"
   s.extra_rdoc_files = [
     "LICENSE.txt",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: super_module
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Andy Maleh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-06 00:00:00.000000000 Z
+date: 2015-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: method_source