extensible 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 77a0368abe54f48d7dce5ffbbea97d6b932578d3
+  data.tar.gz: f297fa02fd05537287e1473f5758f25041df0c85
+SHA512:
+  metadata.gz: cc7f44628796c89d5ce517d0606542189681d6213232d1be546832da17b7c9a1cb869f48e1d948e40372442fa14c80a65ef9952a30a57b53d76efe2511d79b7a
+  data.tar.gz: d165a474bc6fa83f98a0b5691e028504b31bf764a498d5814359e39b8c500fc3863834ea959b0b34b6dfce7abb30600f36a6439e29c19bf21475c249b7237e51

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.buildpath
+.project

data/.rubocop.yml

@@ -0,0 +1,10 @@
+Metrics/LineLength:
+  Max: 120
+Style/AndOr:
+  EnforcedStyle: conditionals
+Style/HashSyntax:
+  EnforcedStyle: ruby19
+Style/SpaceInsideBlockBraces:
+  SpaceBeforeBlockParameters: false
+Style/StringLiterals:
+  EnforcedStyle: double_quotes

data/.ruby-version

@@ -0,0 +1 @@
+2.2.0

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+rvm:
+- ruby-head
+- 2.2
+- 2.1
+- 2.0
+- 1.9.3
+- 1.9.2
+- jruby-head
+- jruby-1.7
+- rbx
+bundler_args: "--without development"
+addons:
+  code_climate:
+    repo_token:
+      secure: E3bOUINqN9inAqw0EsziZGyTzwThdrVrPuiRN6LQYIc7tHWkJBY0UO+tNvpj0tQcF3ViBy8Lbi26W2Fy+y0FWR163AXxQ8wu6Tu21es+sIPUxxnr/WFbVc7CEsE68ExsfNUciHHa82xnHECYaSqpR7gLHeMW7wFksdQvcnNMr38=

data/Gemfile

@@ -0,0 +1,18 @@
+source "https://rubygems.org"
+gemspec
+
+group :development do
+  gem "byebug", "~> 3.5.1"
+  gem "guard-rspec", "~> 4.5.0"
+  gem "guard-rubocop", "~> 1.2.0"
+  gem "libnotify", "~> 0.9.1"
+  gem "pry", "~> 0.10.1"
+  gem "rubocop", "~> 0.29.0"
+end
+
+group :development, :test do
+  gem "codeclimate-test-reporter", "~> 0.4.6"
+  gem "rake", "~> 10.4.2"
+  gem "rspec", "~> 3.2.0"
+  gem "simplecov", "~> 0.9.1"
+end

data/Guardfile

@@ -0,0 +1,12 @@
+guard :rubocop, all_on_start: false do
+  watch(/^.+\.rb$/)
+  watch(/^(?:.+\/)?\.rubocop\.yml$/) {|m| File.dirname(m[0]) }
+  watch(/^(?:.+\/)?.+\.gemspec$/)
+  watch(/^(?:.+\/)?(?:Gem|Rake)file$/)
+end
+
+guard :rspec, cmd: "bundle exec rspec -fd" do
+  watch(/^spec\/.+_spec\.rb$/)
+  watch(/^lib\/(.+)\.rb$/) {|m| "spec/lib/#{m[1]}_spec.rb" }
+  watch("spec/spec_helper.rb") { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Gabriel de Oliveira
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,147 @@
+# Extensible
+
+[![Gem Version](http://img.shields.io/gem/v/extensible.svg)][gem]
+[![Build Status](http://img.shields.io/travis/gdeoliveira/extensible.svg)][travis]
+[![Code Climate](http://img.shields.io/codeclimate/github/gdeoliveira/extensible.svg)][codeclimate]
+[![Test Coverage](http://img.shields.io/codeclimate/coverage/github/gdeoliveira/extensible.svg)][codeclimate]
+[![Dependency Status](http://img.shields.io/gemnasium/gdeoliveira/extensible.svg)][gemnasium]
+[![Inline docs](http://inch-ci.org/github/gdeoliveira/extensible.svg?branch=master)][inch-ci]
+
+[gem]: https://rubygems.org/gems/extensible
+[travis]: http://travis-ci.org/gdeoliveira/extensible
+[codeclimate]: https://codeclimate.com/github/gdeoliveira/extensible
+[gemnasium]: https://gemnasium.com/gdeoliveira/extensible#development-dependencies
+[inch-ci]: http://inch-ci.org/github/gdeoliveira/extensible
+
+Use Extensible on your custom extensions in order to get the following set of advantages over traditional extensions that override the `Module#extended` method directly:
+
+- Calls to `super` are handled internally to ensure all your _extensible_ extensions are properly initialized.
+- Your _extensible_ extensions will be automatically able to become the base of other, more specific extensions while proper initialization is maintained by simply including them.
+- Bundle several _extensible_ extensions in a single module by including them and they will all be correctly initialized when extending the bundler module.
+
+Specific examples for each of these scenarios can be found in the [usage](#usage) section.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "extensible"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install extensible
+
+## When should I use Extensible?
+
+You should use Extensible every time you're implementing a module that is intended to be used as an extension for a module or a class **and** that extension needs to have some initialization code.
+
+In short: if you are going to override `Module#extended`, use Extensible instead.
+
+## <a name="usage"></a>Usage
+
+#### Basic
+
+Creating an _extensible_ extension module is, arguably, simpler than creating a traditional extension that overrides `Module#extended`. Note that we do not need to call `super` within the code block since it will be called "under the hood" _before_ the code is executed:
+
+```ruby
+module MyExtension
+  extend Extensible
+  when_extended {|m| puts "#{self} has extended #{m}." }
+end
+```
+
+As you would expect, this is what happens when you use your _extensible_ extension in a class (or module):
+
+```ruby
+class MyClass
+  extend MyExtension
+end  #=> MyExtension has extended MyClass.
+```
+
+#### Extending extensions
+
+The extensions you create using Extensible are "extensible" in the sense that you (or someone else) can use them as the base for other, more specific extensions. The best bit is you get this at no additional cost. Simply include them and extend away!
+
+Suppose we have a base extension that sets an instance variable that holds the reversed name of the module or class extending it:
+
+```ruby
+module MyBaseExtension
+  extend Extensible
+  when_extended do |m|
+    m.instance_variable_set(:@reversed_name, m.to_s.reverse)
+  end
+end
+```
+
+Now we can use `MyBaseExtension` on its own, but we can also _extend_ it to, for example, create a reader method for the `@reversed_name` variable by including it on our more specific `MySubExtension`:
+
+```ruby
+module MySubExtension
+  include MyBaseExtension
+  attr_reader :reversed_name
+end
+```
+
+We can now extend `MySubExtension` ensuring that the initialization routine of `MyBaseExtension` is executed as expected:
+
+```ruby
+class MyClass
+  extend MySubExtension
+end
+
+MyClass.reversed_name  #=> "ssalCyM"
+```
+
+Note: `MySubExtension` could have (if needed) extended Extensible to provide its own initialization routine. In this case both initialization routines (the one for `MyBaseExtension` and the one for `MySubExtension`) would have been executed when `MyClass` extended it.
+
+#### Bundling extensions
+
+Traditional extensions that override the `Module#extended` method work correctly as long as they are explicitly extended in the module or class that will ultimately use them. This can become really cumbersome really fast when you want to apply several extensions to a set of different modules or classes.
+
+Using _extensible_ extensions you can bundle many of them within a single module, and then extend all of them at the same time by extending the bundler module.
+
+Suppose you have two extensions (`A` and `B`) that you want to bundle together:
+
+```ruby
+module A
+  extend Extensible
+  when_extended { puts "A was extended!" }
+end
+
+module B
+  extend Extensible
+  when_extended { puts "B was extended!" }
+end
+```
+
+Simply include them in your bundler module:
+
+```ruby
+module Bundle
+  include A
+  include B
+end
+```
+
+And extend it!
+
+```ruby
+module MyClass
+  extend Bundle
+end  #=> A was extended!
+     #=> B was extended!
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/gdeoliveira/extensible/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am "Add some feature"`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+Dir[File.join(File.dirname(__FILE__), "tasks", "**", "*.rb")].each do |file|
+  require file
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :coverage

data/extensible.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "extensible/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "extensible"
+  spec.version = Extensible::VERSION
+  spec.authors = ["Gabriel de Oliveira"]
+  spec.email = ["deoliveira.gab@gmail.com"]
+  spec.summary = "Ruby extensions made easy."
+  spec.description = "Use Extensible on your custom extensions in order to get the following set of advantages over" \
+                     "traditional extensions that override the `Module#extended` method directly:\n\n" \
+                     "- Calls to `super` are handled internally to ensure all your _extensible_ extensions are" \
+                     "properly initialized.\n" \
+                     "- Your _extensible_ extensions will be automatically able to become the base of other, more" \
+                     "specific extensions while proper initialization is maintained by simply including them.\n" \
+                     "- Bundle several _extensible_ extensions in a single module by including them and they will all" \
+                     "be correctly initialized when extending the bundler module."
+  spec.homepage = "https://github.com/gdeoliveira/extensible"
+  spec.license = "MIT"
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.test_files = spec.files.grep(/^spec\//)
+  spec.require_paths = ["lib"]
+  spec.rdoc_options << "--title=Extensible"
+end

data/lib/extensible/constants.rb

@@ -0,0 +1,9 @@
+module Extensible
+  ##
+  # Contains error message constants.
+  module Error
+    ##
+    # Describes calling a method that expects a code block but isn't provided one.
+    BLOCK_NOT_GIVEN = "code block was expected".freeze
+  end
+end

data/lib/extensible/extension_kernel.rb

@@ -0,0 +1,23 @@
+require "extensible/extension_kernel_template"
+
+module Extensible # rubocop:disable Style/Documentation
+  ##
+  # A custom ExtensionKernelTemplate clone that is extended by Extensible to make it, well, extensible.
+  ExtensionKernel = ExtensionKernelTemplate.clone.module_eval do
+    private # rubocop:disable Style/EmptyLinesAroundAccessModifier
+
+    def extended(submodule)
+      super
+
+      unless submodule.const_defined?(:ExtensionKernel, false)
+        kernel = ExtensionKernelTemplate.clone
+        submodule.const_set(:ExtensionKernel, kernel)
+        submodule.extend kernel
+      end
+
+      self
+    end
+
+    self
+  end
+end

data/lib/extensible/extension_kernel_template.rb

@@ -0,0 +1,35 @@
+module Extensible
+  ##
+  # ExtensionKernelTemplate serves as the initial template for all extension kernels that are used internally by
+  # Extensible. Each extensible module will extend a clone of ExtensionKernelTemplate that will allow it to execute
+  # its own initialization code.
+  module ExtensionKernelTemplate
+    class << self
+      private
+
+      ##
+      # call-seq:
+      #   initialize_copy(_source) => extension_kernel_template
+      #
+      # Passes +_source+ to +super+ and overrides the <tt>Module#included</tt> method in order to extend self on
+      # including modules.
+      #
+      # Returns self object.
+      def initialize_copy(_source)
+        super
+
+        this_kernel = self
+
+        define_method :included do |submodule|
+          super submodule
+          submodule.extend this_kernel
+          self
+        end
+
+        private :included
+
+        self
+      end
+    end
+  end
+end

data/lib/extensible/version.rb

@@ -0,0 +1,39 @@
+##
+# Use Extensible on your custom extensions in order to get a set of advantages over traditional extensions that override
+# the <tt>Module#extended</tt> method directly. When _extending_ Extensible you will be able to define your
+# initialization code (similar to using <tt>Module#extended</tt>) via the when_extended method.
+#
+#   module MyExtension
+#     extend Extensible
+#     when_extended {|m| puts "#{self} has extended #{m}." }
+#   end
+#
+#   class MyClass
+#     extend MyExtension
+#   end  #=> MyExtension has extended MyClass.
+#
+# Extensible is, itself, extensible. This means that you will be able to extend it further or bundle it together with
+# other extensible modules by _including_ it in your module.
+#
+#   module MyExtensibleExtension
+#     include Extensible
+#
+#     def custom_when_extended(&block)
+#       puts "Defining initialization code..."
+#       when_extended &block
+#     end
+#   end
+#
+#   module MyExtension
+#     extend MyExtensibleExtension
+#     custom_when_extended {|m| puts "#{self} has extended #{m}." }
+#   end  #=> Defining initialization code...
+#
+#   class MyClass
+#     extend MyExtension
+#   end  #=> MyExtension has extended MyClass.
+module Extensible
+  ##
+  # Current version of Extensible.
+  VERSION = "0.0.1".freeze
+end

data/lib/extensible.rb

@@ -0,0 +1,35 @@
+require "extensible/constants"
+require "extensible/extension_kernel"
+require "extensible/version"
+
+module Extensible # rubocop:disable Style/Documentation
+  extend ExtensionKernel
+
+  private
+
+  ##
+  # call-seq:
+  #   when_extended() {|module| ... } => self
+  #
+  # The +when_extended+ method accepts a code block that will be executed every time this module is extended in a
+  # manner similar to <tt>Module#extended</tt>. The code block will be passed a +module+ parameter containing the module
+  # that is being extended. There is no need to make explicit calls to +super+ as those will be made internally by
+  # Extensible.
+  #
+  # Returns self object.
+  def when_extended(&b)
+    fail(ArgumentError, Error::BLOCK_NOT_GIVEN) unless block_given?
+
+    self::ExtensionKernel.module_eval do
+      define_method :extended do |submodule|
+        super submodule
+        b.call submodule
+        self
+      end
+
+      private :extended
+    end
+
+    self
+  end
+end

data/spec/.rubocop.yml

@@ -0,0 +1,4 @@
+inherit_from:
+  - ../.rubocop.yml
+Metrics/LineLength:
+  Max: 140

data/spec/lib/extensible/constants_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe Extensible::Error do
+  subject { described_class.constants.map {|c| described_class.const_get c } }
+
+  it { is_expected.to all(be_frozen) }
+end

data/spec/lib/extensible/version_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe Extensible::VERSION do
+  it { is_expected.not_to be_nil }
+end

data/spec/lib/extensible_spec.rb

@@ -0,0 +1,195 @@
+require "spec_helper"
+
+describe Extensible do
+  context "#when_extended" do
+    it "raises an error if code block is not provided" do
+      m = Module.new
+
+      expect do
+        m.module_eval do
+          extend Extensible
+          when_extended
+        end
+      end.to raise_error(ArgumentError)
+    end
+  end
+
+  context "hierarchy" do
+    let(:extensible_base_extension_1) do
+      Module.new.tap do |m|
+        m.module_eval do
+          include Extensible
+        end
+      end
+    end
+
+    let(:extensible_base_extension_2) do
+      Module.new.tap do |m|
+        m.module_eval do
+          include Extensible
+          extend Extensible
+          when_extended do |sm|
+            sm.const_set(:EBE_2_CALLED, true)
+          end
+        end
+      end
+    end
+
+    let(:extensible_sub_extension) do
+      ebe_1 = extensible_base_extension_1
+      ebe_2 = extensible_base_extension_2
+      Module.new.tap do |m|
+        m.module_eval do
+          include ebe_1
+          include ebe_2
+        end
+      end
+    end
+
+    let(:base_extension_1) do
+      ese = extensible_sub_extension
+      Module.new.tap do |m|
+        m.module_eval do
+          extend ese
+          when_extended do |sm|
+            sm.const_set(:BE_1_CALLED, true)
+          end
+        end
+      end
+    end
+
+    let(:base_extension_2) do
+      ebe_1 = extensible_base_extension_1
+      Module.new.tap do |m|
+        m.module_eval do
+          extend ebe_1
+          when_extended do |sm|
+            sm.const_set(:BE_2_CALLED, true)
+          end
+        end
+      end
+    end
+
+    let(:sub_extension) do
+      be_1 = base_extension_1
+      be_2 = base_extension_2
+      Module.new.tap do |m|
+        m.module_eval do
+          include be_1
+          include be_2
+        end
+      end
+    end
+
+    subject do
+      se = sub_extension
+      Class.new.tap do |c|
+        c.class_eval do
+          extend se
+        end
+      end
+    end
+
+    def extension_ids(mod)
+      mod.singleton_class.ancestors.map(&:object_id)
+    end
+
+    it "adds the extensible extension kernel to all extensible extensions" do
+      expect(extension_ids(Extensible)).to include(Extensible::ExtensionKernel.object_id)
+      expect(extension_ids(extensible_base_extension_1)).to include(Extensible::ExtensionKernel.object_id)
+      expect(extension_ids(extensible_base_extension_2)).to include(Extensible::ExtensionKernel.object_id)
+      expect(extension_ids(extensible_sub_extension)).to include(Extensible::ExtensionKernel.object_id)
+    end
+
+    it "does not add the extensible extension kernel to non-extensible extensions" do
+      expect(extension_ids(base_extension_1)).not_to include(Extensible::ExtensionKernel.object_id)
+      expect(extension_ids(base_extension_2)).not_to include(Extensible::ExtensionKernel.object_id)
+      expect(extension_ids(sub_extension)).not_to include(Extensible::ExtensionKernel.object_id)
+      expect(extension_ids(subject)).not_to include(Extensible::ExtensionKernel.object_id)
+    end
+
+    it "adds the `extensible_base_extension_2` extension kernel to modules that include it" do
+      expect(extension_ids(extensible_base_extension_2)).to include(extensible_base_extension_2::ExtensionKernel.object_id)
+      expect(extension_ids(extensible_sub_extension)).to include(extensible_base_extension_2::ExtensionKernel.object_id)
+    end
+
+    it "does not add the `extensible_base_extension_2` extension kernel to modules that do not include it" do
+      expect(extension_ids(Extensible)).not_to include(extensible_base_extension_2::ExtensionKernel.object_id)
+      expect(extension_ids(extensible_base_extension_1)).not_to include(extensible_base_extension_2::ExtensionKernel.object_id)
+      expect(extension_ids(base_extension_1)).not_to include(extensible_base_extension_2::ExtensionKernel.object_id)
+      expect(extension_ids(base_extension_2)).not_to include(extensible_base_extension_2::ExtensionKernel.object_id)
+      expect(extension_ids(sub_extension)).not_to include(extensible_base_extension_2::ExtensionKernel.object_id)
+      expect(extension_ids(subject)).not_to include(extensible_base_extension_2::ExtensionKernel.object_id)
+    end
+
+    it "adds the `base_extension_1` extension kernel to modules that include it" do
+      expect(extension_ids(base_extension_1)).to include(base_extension_1::ExtensionKernel.object_id)
+      expect(extension_ids(sub_extension)).to include(base_extension_1::ExtensionKernel.object_id)
+    end
+
+    it "does not add the `base_extension_1` extension kernel to modules that do not include it" do
+      expect(extension_ids(Extensible)).not_to include(base_extension_1::ExtensionKernel.object_id)
+      expect(extension_ids(extensible_base_extension_1)).not_to include(base_extension_1::ExtensionKernel.object_id)
+      expect(extension_ids(extensible_base_extension_2)).not_to include(base_extension_1::ExtensionKernel.object_id)
+      expect(extension_ids(extensible_sub_extension)).not_to include(base_extension_1::ExtensionKernel.object_id)
+      expect(extension_ids(base_extension_2)).not_to include(base_extension_1::ExtensionKernel.object_id)
+      expect(extension_ids(subject)).not_to include(base_extension_1::ExtensionKernel.object_id)
+    end
+
+    it "adds the `base_extension_2` extension kernel to modules that include it" do
+      expect(extension_ids(base_extension_2)).to include(base_extension_2::ExtensionKernel.object_id)
+      expect(extension_ids(sub_extension)).to include(base_extension_2::ExtensionKernel.object_id)
+    end
+
+    it "does not add the `base_extension_2` extension kernel to modules that do not include it" do
+      expect(extension_ids(Extensible)).not_to include(base_extension_2::ExtensionKernel.object_id)
+      expect(extension_ids(extensible_base_extension_1)).not_to include(base_extension_2::ExtensionKernel.object_id)
+      expect(extension_ids(extensible_base_extension_2)).not_to include(base_extension_2::ExtensionKernel.object_id)
+      expect(extension_ids(extensible_sub_extension)).not_to include(base_extension_2::ExtensionKernel.object_id)
+      expect(extension_ids(base_extension_1)).not_to include(base_extension_2::ExtensionKernel.object_id)
+      expect(extension_ids(subject)).not_to include(base_extension_2::ExtensionKernel.object_id)
+    end
+
+    it "executes the `extensible_base_extension_2` extension code on modules that extend it" do
+      expect(base_extension_1.const_defined?(:EBE_2_CALLED, false)).to be(true)
+    end
+
+    it "does not execute `extensible_base_extension_2` extension code on modules that do not extend it" do
+      expect(Extensible.const_defined?(:EBE_2_CALLED, false)).to be(false)
+      expect(extensible_base_extension_1.const_defined?(:EBE_2_CALLED, false)).to be(false)
+      expect(extensible_base_extension_2.const_defined?(:EBE_2_CALLED, false)).to be(false)
+      expect(extensible_sub_extension.const_defined?(:EBE_2_CALLED, false)).to be(false)
+      expect(base_extension_2.const_defined?(:EBE_2_CALLED, false)).to be(false)
+      expect(sub_extension.const_defined?(:EBE_2_CALLED, false)).to be(false)
+      expect(subject.const_defined?(:EBE_2_CALLED, false)).to be(false)
+    end
+
+    it "executes the `base_extension_1` extension code on modules that extend it" do
+      expect(subject.const_defined?(:BE_1_CALLED, false)).to be(true)
+    end
+
+    it "does not execute `base_extension_1` extension code on modules that do not extend it" do
+      expect(Extensible.const_defined?(:BE_1_CALLED, false)).to be(false)
+      expect(extensible_base_extension_1.const_defined?(:BE_1_CALLED, false)).to be(false)
+      expect(extensible_base_extension_2.const_defined?(:BE_1_CALLED, false)).to be(false)
+      expect(extensible_sub_extension.const_defined?(:BE_1_CALLED, false)).to be(false)
+      expect(base_extension_1.const_defined?(:BE_1_CALLED, false)).to be(false)
+      expect(base_extension_2.const_defined?(:BE_1_CALLED, false)).to be(false)
+      expect(sub_extension.const_defined?(:BE_1_CALLED, false)).to be(false)
+    end
+
+    it "executes the `base_extension_2` extension code on modules that extend it" do
+      expect(subject.const_defined?(:BE_2_CALLED, false)).to be(true)
+    end
+
+    it "does not execute `base_extension_2` extension code on modules that do not extend it" do
+      expect(Extensible.const_defined?(:BE_2_CALLED, false)).to be(false)
+      expect(extensible_base_extension_1.const_defined?(:BE_2_CALLED, false)).to be(false)
+      expect(extensible_base_extension_2.const_defined?(:BE_2_CALLED, false)).to be(false)
+      expect(extensible_sub_extension.const_defined?(:BE_2_CALLED, false)).to be(false)
+      expect(base_extension_1.const_defined?(:BE_2_CALLED, false)).to be(false)
+      expect(base_extension_2.const_defined?(:BE_2_CALLED, false)).to be(false)
+      expect(sub_extension.const_defined?(:BE_2_CALLED, false)).to be(false)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+unless ENV["COVERAGE"].nil?
+  require "codeclimate-test-reporter"
+  SimpleCov.start do
+    formatter SimpleCov::Formatter::MultiFormatter[
+      SimpleCov::Formatter::HTMLFormatter,
+      CodeClimate::TestReporter::Formatter
+    ]
+    add_filter "/spec/"
+  end
+end
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "extensible"
+
+RSpec.configure do |config|
+  config.color = true
+  config.order = :rand
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/tasks/console.rb

@@ -0,0 +1,25 @@
+desc "Open a console with the #{Bundler::GemHelper.gemspec.name} gem loaded"
+task :console do
+  require Bundler::GemHelper.gemspec.name
+
+  if RUBY_VERSION >= "2"
+    begin
+      require "byebug"
+    rescue LoadError # rubocop:disable Lint/HandleExceptions
+    end
+  else
+    begin
+      require "debugger"
+    rescue LoadError # rubocop:disable Lint/HandleExceptions
+    end
+  end
+
+  begin
+    require "pry"
+    Pry.start
+  rescue LoadError
+    require "irb"
+    ARGV.clear
+    IRB.start
+  end
+end

data/tasks/coverage.rb

@@ -0,0 +1,5 @@
+desc "Run tests and generate coverage report"
+task :coverage do
+  ENV["COVERAGE"] = "true"
+  Rake::Task[:spec].invoke
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: extensible
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gabriel de Oliveira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-10 00:00:00.000000000 Z
+dependencies: []
+description: |-
+  Use Extensible on your custom extensions in order to get the following set of advantages overtraditional extensions that override the `Module#extended` method directly:
+
+  - Calls to `super` are handled internally to ensure all your _extensible_ extensions areproperly initialized.
+  - Your _extensible_ extensions will be automatically able to become the base of other, morespecific extensions while proper initialization is maintained by simply including them.
+  - Bundle several _extensible_ extensions in a single module by including them and they will allbe correctly initialized when extending the bundler module.
+email:
+- deoliveira.gab@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- extensible.gemspec
+- lib/extensible.rb
+- lib/extensible/constants.rb
+- lib/extensible/extension_kernel.rb
+- lib/extensible/extension_kernel_template.rb
+- lib/extensible/version.rb
+- spec/.rubocop.yml
+- spec/lib/extensible/constants_spec.rb
+- spec/lib/extensible/version_spec.rb
+- spec/lib/extensible_spec.rb
+- spec/spec_helper.rb
+- tasks/console.rb
+- tasks/coverage.rb
+homepage: https://github.com/gdeoliveira/extensible
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--title=Extensible"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Ruby extensions made easy.
+test_files:
+- spec/.rubocop.yml
+- spec/lib/extensible/constants_spec.rb
+- spec/lib/extensible/version_spec.rb
+- spec/lib/extensible_spec.rb
+- spec/spec_helper.rb