super_module 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f7d062de77d91c8bd5fd0e87e4c140fcadfc3ae81f6a91a0673a133aa26cd99
-  data.tar.gz: 80d078ac51cd2a8d3f89dd37941a84de73b2c790f36b3d4fdadf2d4d2d63ed79
+  metadata.gz: a4faa73d0b49aef392b5dd1c26df10e4fc7ae5f9c528284503cd68df38c2381b
+  data.tar.gz: 9c48055a31b17ae2cdd554314cc3dbbf4d10e6eb2a93d4f21636663ce0f0a6c5
 SHA512:
-  metadata.gz: e2701d71b39ed35ff6005d48c7ad076205bee6c6f3540aa76c8d48fd4f04ae8d6a73f230a7c1ab6dbfb092341c48fb2d05413954eb7800f3e760a0215c19bab3
-  data.tar.gz: 9ef86a39a120bd5ba2e65e8026b6672234705ae6833b79ae8ef460d70121eb28bf1c05708a1dcfe820dfe67c82327d6f01352256da34c4e981bead9d8d82b783
+  metadata.gz: 37e9470e3ebe8977cf24425169ac7976304ba4d4eb1c0ca8069fa761813184d24e182235cc57ae01674f09189e22fe2681bd0b3a580e23aff50e323cc47ef435
+  data.tar.gz: 998e4a95be965413b20f49d2dad072a3458b61fd13e34eb33db601bd96ee3f7581c015ccb0e8872b8f3ef329a585dea902cccc165ac7921e58c503a6b2396892

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Change Log
 
+## 1.4.0
+
+- Support aliased methods
+- Support safely calling self.included(base) in super module via super_module_included {|base| ... }
+
 ## 1.3.1
 
 - Fixed issue with super module containing class methods with default arguments

data/README.md

@@ -94,7 +94,7 @@ end
 ```
 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.
+As a result, [SuperModule](https://rubygems.org/gems/super_module) collapses the difference between extending a super class and including a [super module](#glossary-and-definitions), 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.
 
@@ -104,7 +104,7 @@ In other words, [SuperModule](https://rubygems.org/gems/super_module) furthers R
 
 <b>Using [Bundler](http://bundler.io/)</b>
 
-Add the following to Gemfile: <pre>gem 'super_module', '1.3.1'</pre>
+Add the following to Gemfile: <pre>gem 'super_module', '1.4.0'</pre>
 
 And run the following command: <pre>bundle</pre>
 
@@ -118,7 +118,7 @@ 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) Simply include SuperModule in your module (just like you would do any other Ruby module)
+#### 2) Simply include SuperModule at the top of your module definition before anything else.
 
 ```ruby
 module UserIdentifiable
@@ -138,7 +138,9 @@ module UserIdentifiable
 end
 ```
 
-#### 3) Mix newly defined module into a class or another super module
+Note: Even if you are including another [super module](#glossary-and-definitions) in your new [super module](#glossary-and-definitions), you must `include SuperModule` at the top of your module definition before anything else.
+
+#### 3) Mix newly defined module into a class or another [super module](#glossary-and-definitions)
 
 ```ruby
 class ClubParticipation < ActiveRecord::Base
@@ -166,22 +168,21 @@ ClubParticipation.create(club_id: club.id, user_id: user.id).slug
 CourseEnrollment.new(course_id: course.id).valid?
 ```
 
-## Glossary and Definitions
+## Usage Notes
 
- * SuperModule: name of the library and Ruby module that provides functionality via mixin
- * Super module: any Ruby module that mixes in SuperModule
- * 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
+ * SuperModule must always be included at the top of a module's body at [code-time](#glossary-and-definitions)
+ * SuperModule inclusion can be optionally followed by other basic or [super module](#glossary-and-definitions) inclusions
+ * A [super module](#glossary-and-definitions) can only be included in a class or another [super module](#glossary-and-definitions)
 
-## Usage Details
+## Glossary and Definitions
 
- * SuperModule must always be included at the top of a module's body at code-time
- * SuperModule inclusion can be optionally followed by other basic or super module inclusions
- * 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)
+* SuperModule: name of the library and Ruby module that provides functionality via mixin
+* Super module: any Ruby module that mixes in SuperModule
+* 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
 
 ## IRB Example
 
@@ -192,25 +193,25 @@ require 'rubygems' # to be backwards compatible with Ruby 1.8.7
 require 'super_module'
 
 module RequiresAttributes
-  include SuperModule
+ include SuperModule
 
-  def self.requires(*attributes)
-    attributes.each {|attribute| required_attributes << attribute}
-  end
+ def self.requires(*attributes)
+   attributes.each {|attribute| required_attributes << attribute}
+ end
 
-  def self.required_attributes
-    @required_attributes ||= []
-  end
+ def self.required_attributes
+   @required_attributes ||= []
+ end
 
-  def requirements_satisfied?
-    !!self.class.required_attributes.reduce(true) { |result, required_attribute| result && send(required_attribute) }
-  end
+ def requirements_satisfied?
+   !!self.class.required_attributes.reduce(true) { |result, required_attribute| result && send(required_attribute) }
+ end
 end
 
 class MediaAuthorization
-  include RequiresAttributes
-  attr_accessor :user_id, :credit_card_id
-  requires :user_id, :credit_card_id
+ include RequiresAttributes
+ attr_accessor :user_id, :credit_card_id
+ requires :user_id, :credit_card_id
 end
 ```
 
@@ -256,40 +257,121 @@ media_authorization.requirements_satisfied?
 ```
 => true
 
-## How Does It Work?
-
-V2 has a much simpler algorithm than V1 that goes as follows:
+## Overriding `self.included(base)`
 
-1. Handle invocation of `super_module(name, &super_module_body)` method anywhere in the Ruby code where the block it receives represents the super module body, including instance methods, and class methods, and class body invocations.
-2. Clone `SuperModule` and store in it the passed in `super_module_body` block
-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`
+With `SuperModule`, hooking into `self.included(base)` is no longer needed for most cases. Still, there rare exceptions where that might be needed to execute some meta-programmatic logic. Fortunately, `SuperModule` offers a mechanism to do so.
 
-## Warnings
+`SuperModule` relies on `self.included(base)`, so modules mixing it in must refrain from implementing `self.included(base)` directly (`SuperModule` will automatically prevent that by providing instructions should one attempt to do so).
 
-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.
+In order for a [super module](#glossary-and-definitions) to hook into `self.included(base)` and add extra logic, it must do so via `super_module_included {|base| ... }` instead, which safely appends that logic to the work of `SuperModule` as well as other nested [super module](#glossary-and-definitions)s.
 
-2) Given [SuperModule](https://rubygems.org/gems/super_module)'s implementation relies on `self.included(base)`, sub-modules must not hook into it.
+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
-module AdminIdentifiable
-    include SuperModule
-    include UserIdentifiable
-
-    class << self
-        def included(base)
-            included_super_module(base)
-            # do some extra rare meta-programming work
-            # like conditional inclusion of other modules
-            # or conditional definition of methods
-        end
+module V1::SummarizedActiveModel
+  include SuperModule
+
+  super_module_included do |klass|
+    if klass.name.split(/::/).last.start_with?('Fake')
+      klass.extend(FakeClassMethods1)
+    end
+  end
+
+  module FakeClassMethods1
+    def fake_summary
+      'This is a fake summary.'
+    end
+  end
+
+  class << self
+    def self.validates(attribute, options = {})
+      validations << [attribute, options]
+    end
+
+    def self.validations
+      @validations ||= []
+    end
+
+    def summary
+      validations.flatten.map(&:to_s).join("/")
+    end
+  end
+end
+
+module V1::ExtraSummarizedActiveModel
+  include SuperModule
+
+  include ::V1::SummarizedActiveModel
+
+  super_module_included do |klass|
+    if klass.name.split(/::/).last.start_with?('Fake')
+      klass.extend(FakeClassMethods2)
+    end
+  end
+
+  module FakeClassMethods2
+    def fake_extra
+      'This is fake extra.'
+    end
+  end
+
+  class << self
+    def extra
+      "This is extra."
     end
+  end
 end
+
+class V1::SummarizedActiveRecord
+  include ::V1::SummarizedActiveModel
+end
+
+class V1::FakeSummarizedActiveRecord
+  include ::V1::SummarizedActiveModel
+end
+
+class V1::ExtraSummarizedActiveRecord
+  include ::V1::ExtraSummarizedActiveModel
+end
+
+class V1::FakeExtraSummarizedActiveRecord
+  include ::V1::ExtraSummarizedActiveModel
+end
+
+V1::SummarizedActiveRecord.validates 'foo', {:presence => true}
+V1::SummarizedActiveRecord.validates 'bar', {:presence => true}
+puts V1::SummarizedActiveRecord.summary
+# prints 'foo/{:presence=>true}/bar/{:presence=>true}'
+
+V1::FakeSummarizedActiveRecord.validates 'foo', {:presence => true}
+V1::FakeSummarizedActiveRecord.validates 'bar', {:presence => true}
+puts V1::FakeSummarizedActiveRecord.summary
+# prints 'foo/{:presence=>true}/bar/{:presence=>true}'
+puts V1::FakeSummarizedActiveRecord.fake_summary
+# prints 'This is a fake summary.'
+
+V1::ExtraSummarizedActiveRecord.validates 'foo', {:presence => true}
+V1::ExtraSummarizedActiveRecord.validates 'bar', {:presence => true}
+puts V1::ExtraSummarizedActiveRecord.summary
+# prints 'foo/{:presence=>true}/bar/{:presence=>true}'
+puts V1::ExtraSummarizedActiveRecord.extra
+# prints 'This is extra.'
+
+V1::FakeExtraSummarizedActiveRecord.validates 'foo', {:presence => true}
+V1::FakeExtraSummarizedActiveRecord.validates 'bar', {:presence => true}
+puts V1::FakeExtraSummarizedActiveRecord.summary
+# prints 'foo/{:presence=>true}/bar/{:presence=>true}'
+puts V1::FakeExtraSummarizedActiveRecord.fake_summary
+# prints 'This is a fake summary.'
+puts V1::FakeExtraSummarizedActiveRecord.extra
+# prints 'This is extra.'
+puts V1::FakeExtraSummarizedActiveRecord.fake_extra
+# prints 'This is fake extra.'
 ```
-This does not work for all cases (like multiple levels of super module nesting), and is not recommended, likely causing problems.
 
-Avoid hooking into `self.included(base)` at all costs.
+## Limitations
+
+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.
 
 ## Change Log
 
@@ -309,10 +391,9 @@ The library is quite new and can use all the feedback and help it can get. So, p
 
 ## 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
+None
 
 ## Copyright
 
-Copyright (c) 2014-2016 Andy Maleh. See LICENSE.txt for
+Copyright (c) 2014-2020 Andy Maleh. See LICENSE.txt for
 further details.

data/VERSION

@@ -1 +1 @@
-1.3.1
+1.4.0

data/lib/super_module/v1.rb

@@ -5,6 +5,7 @@ module SuperModule
   module V1
     class << self
       def included(original_base)
+        # TODO maybe avoid class_eval by extending/including instead
         original_base.class_eval do
           extend SuperModule::V1::ModuleBodyMethodCallRecorder
           extend SuperModule::V1::SingletonMethodDefinitionStore
@@ -27,8 +28,21 @@ module SuperModule
             def included(base)
               __define_super_module_singleton_methods(base)
               __invoke_module_body_method_calls(base)
+              super_module_included.each {|block| block.call(base)}
+              if base.ancestors.include?(SuperModule) && !base.is_a?(Class)
+                super_module_included.reverse.each do |block|
+                  base.super_module_included.unshift(block)
+                end
+              end
+            end
+
+            def super_module_included(&block)
+              if block_given?
+                super_module_included << block
+              else
+                @super_module_included_blocks ||= []
+              end
             end
-            alias included_super_module included
           end
         end
       end

data/lib/super_module/v1/module_body_method_call_recorder.rb

@@ -4,7 +4,7 @@ module SuperModule
       def __super_module_singleton_methods_excluded_from_call_recording
         @__super_module_singleton_methods_excluded_from_call_recording ||= [
           :__record_method_call,
-          :__method_signature
+          :__method_signature,
         ]
       end
 
@@ -16,7 +16,6 @@ module SuperModule
         "#{method_name}(#{args.to_a.map(&:to_s).join(",")})"
       end
 
-      #TODO handle case of a method call being passed a block (e.g. validates do custom validator end )
       def __record_method_call(method_name, *args, &block)
         return if self.is_a?(Class)
         __module_body_method_calls << [method_name, args, block]

data/lib/super_module/v1/singleton_method_definition_store.rb

@@ -27,10 +27,9 @@ module SuperModule
           :dbg_puts, #debugger library friendly exclusion
           :define,
           :included,
-          :included_super_module,
+          :super_module_included,
           :included_super_modules,
           :singleton_method_added,
-          :super_module_body
         ]
       end
 
@@ -70,11 +69,14 @@ module SuperModule
       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)
+        the_method = self.method(method_name)
+        method_body = the_method.source
+        method_original_name = the_method.original_name
+        aliased = method_original_name != method_name
+        method_args = __singleton_method_args(method_original_name, method_body)
         method_body = "def #{method_name}\n#{method_body}\nend" if method_args.nil?
         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"
+        method_body.sub(__singleton_method_definition_regex(method_original_name), class_self_method_def_enclosure) + "\nend\n"
       end
 
       def __singleton_method_body(method_name)
@@ -90,6 +92,9 @@ module SuperModule
       end
 
       def singleton_method_added(method_name)
+        if method_name.to_s == 'included' && !method(method_name).source_location.first.include?('super_module/v1')
+          raise 'Do not implement "self.included(base)" hook for a super module! Use "super_module_included {|base| ... }" instead.'
+        end
         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]
@@ -98,7 +103,7 @@ module SuperModule
       end
 
       def self.extended(base)
-        base.extend(SuperModule::ModuleBodyMethodCallRecorder) unless base.respond_to?(:__record_method_call)
+        base.extend(SuperModule::V1::ModuleBodyMethodCallRecorder) unless base.is_a?(SuperModule::V1::ModuleBodyMethodCallRecorder)
         base.singleton_method_added(:__method_signature)
         base.singleton_method_added(:__record_method_call)
       end

data/spec/lib/super_module_spec.rb

@@ -19,28 +19,53 @@ end
 module V1::SummarizedActiveModel
   include SuperModule
 
-  def self.included(klass)
-    included_super_module(klass)
+  super_module_included do |klass|
     if klass.name.split(/::/).last.start_with?('Fake')
-      klass.extend(FakeClassMethods)
+      klass.extend(FakeClassMethods1)
     end
   end
-  
-  def self.validates(attribute, options)
-    super # test that singleton class inheritance works
+
+  module FakeClassMethods1
+    def fake_summary
+      'This is a fake summary.'
+    end
+  end
+
+  class << self
+    def validates(attribute, options)
+      super # test that singleton class inheritance works
+    end
+
+    def validations
+      super # test that singleton class inheritance works
+    end
+
+    def summary
+      validations.flatten.map(&:to_s).join("/")
+    end
   end
+end
+
+module V1::ExtraSummarizedActiveModel
+  include SuperModule
 
-  def self.validations
-    super # test that singleton class inheritance works
+  include ::V1::SummarizedActiveModel
+
+  super_module_included do |klass|
+    if klass.name.split(/::/).last.start_with?('Fake')
+      klass.extend(FakeClassMethods2)
+    end
   end
 
-  def self.summary
-    validations.flatten.map(&:to_s).join("/")
+  module FakeClassMethods2
+    def fake_extra
+      'This is fake extra.'
+    end
   end
 
-  module FakeClassMethods
-    def fake_summary
-      'This is a fake summary.'
+  class << self
+    def extra
+      "This is extra."
     end
   end
 end
@@ -53,6 +78,14 @@ class V1::FakeSummarizedActiveRecord < V1::FakeActiveRecord
   include ::V1::SummarizedActiveModel
 end
 
+class V1::ExtraSummarizedActiveRecord < V1::FakeActiveRecord
+  include ::V1::ExtraSummarizedActiveModel
+end
+
+class V1::FakeExtraSummarizedActiveRecord < V1::FakeActiveRecord
+  include ::V1::ExtraSummarizedActiveModel
+end
+
 describe SuperModule do
   context V1 do
     context "standalone module usage" do
@@ -62,6 +95,16 @@ describe SuperModule do
         subject.validates 'foo', {:presence => true}
         expect(subject.validations).to include(['foo', {:presence => true}])
       end
+
+      it 'raises error if super module implements self.included(base)' do
+        expect do
+          module SomeSuperModule
+            include SuperModule
+            def self.included(base)
+            end
+          end
+        end.to raise_error('Do not implement "self.included(base)" hook for a super module! Use "super_module_included {|base| ... }" instead.')
+      end
     end
 
     context "included by a module (Foo) that is included by a class (FooActiveRecord)" do
@@ -252,6 +295,22 @@ describe SuperModule do
         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
+      it 'returns extra' do
+        V1::ExtraSummarizedActiveRecord.validates 'foo', {:presence => true}
+        V1::ExtraSummarizedActiveRecord.validates 'bar', {:presence => true}
+        expect(V1::ExtraSummarizedActiveRecord.summary).to eq('foo/{:presence=>true}/bar/{:presence=>true}')
+        expect{V1::ExtraSummarizedActiveRecord.fake_summary}.to raise_error
+        expect(V1::ExtraSummarizedActiveRecord.extra).to eq('This is extra.')
+        expect{V1::ExtraSummarizedActiveRecord.fake_extra}.to raise_error
+      end
+      it 'returns fake extra' do
+        V1::FakeExtraSummarizedActiveRecord.validates 'foo', {:presence => true}
+        V1::FakeExtraSummarizedActiveRecord.validates 'bar', {:presence => true}
+        expect(V1::FakeExtraSummarizedActiveRecord.summary).to eq('foo/{:presence=>true}/bar/{:presence=>true}')
+        expect(V1::FakeExtraSummarizedActiveRecord.fake_summary).to eq('This is a fake summary.')
+        expect(V1::FakeExtraSummarizedActiveRecord.extra).to eq('This is extra.')
+        expect(V1::FakeExtraSummarizedActiveRecord.fake_extra).to eq('This is fake extra.')
+      end
     end
   end
 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.3.1 ruby lib
+# stub: super_module 1.4.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "super_module".freeze
-  s.version = "1.3.1"
+  s.version = "1.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Andy Maleh".freeze]
-  s.date = "2020-03-28"
+  s.date = "2020-04-06"
   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".freeze
   s.extra_rdoc_files = [
     "CHANGELOG.md",
@@ -46,7 +46,7 @@ Gem::Specification.new do |s|
     s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<method_source>.freeze, [">= 0.8.2"])
+      s.add_runtime_dependency(%q<method_source>.freeze, [">= 0.8.2", "< 1.1.0"])
       s.add_development_dependency(%q<jeweler>.freeze, ["~> 2.3.0"])
       s.add_development_dependency(%q<rdoc>.freeze, ["~> 4.2.0"])
       s.add_development_dependency(%q<rspec>.freeze, ["~> 3.2.0"])
@@ -57,7 +57,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<tins>.freeze, ["~> 1.6.0"])
       s.add_development_dependency(%q<term-ansicolor>.freeze, ["~> 1.3.2"])
     else
-      s.add_dependency(%q<method_source>.freeze, [">= 0.8.2"])
+      s.add_dependency(%q<method_source>.freeze, [">= 0.8.2", "< 1.1.0"])
       s.add_dependency(%q<jeweler>.freeze, ["~> 2.3.0"])
       s.add_dependency(%q<rdoc>.freeze, ["~> 4.2.0"])
       s.add_dependency(%q<rspec>.freeze, ["~> 3.2.0"])
@@ -69,7 +69,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<term-ansicolor>.freeze, ["~> 1.3.2"])
     end
   else
-    s.add_dependency(%q<method_source>.freeze, [">= 0.8.2"])
+    s.add_dependency(%q<method_source>.freeze, [">= 0.8.2", "< 1.1.0"])
     s.add_dependency(%q<jeweler>.freeze, ["~> 2.3.0"])
     s.add_dependency(%q<rdoc>.freeze, ["~> 4.2.0"])
     s.add_dependency(%q<rspec>.freeze, ["~> 3.2.0"])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: super_module
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Andy Maleh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-28 00:00:00.000000000 Z
+date: 2020-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: method_source
@@ -17,6 +17,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,6 +27,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: jeweler
   requirement: !ruby/object:Gem::Requirement