include_module 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: de37cd68ed47d17ca31835c5e3e413a66f4a9b13
+  data.tar.gz: 163712749ec437588906a13f530ff4978c02918a
+SHA512:
+  metadata.gz: 29cb5b888d56f91b354662b3e62df476ef39932bced2a5f67a060e2d68a53e8c2d80b87ee324fb966b7e8cf5d761f860853efa57cd0d019d1be2bceaed740ea3
+  data.tar.gz: 775acf4c01dcf37fb824412839259cf0cb1cd4c986bbb39daba8af0fd6e4f1b9f58b971e546443f1487f9baae4d8f7f01edaa97855c33d90f4307f823cd82d58

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 2.1.10
+  - 2.2.5
+  - 2.3.1
+env:
+  - CI=true
+before_install: gem install bundler
+install: bundle install
+script: make test

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+The following are lists of the notable changes included with each release.
+This is intended to help keep people informed about notable changes between
+versions, as well as provide a rough history. Each item is prefixed with
+one of the following labels: `Added`, `Changed`, `Deprecated`,
+`Removed`, `Fixed`, `Security`. We also use [Semantic
+Versioning](http://semver.org) to manage the versions of this gem so
+that you can set version constraints properly.
+
+### [Unreleased](https://github.com/exAspArk/include_module/compare/9bfa492...HEAD)
+
+* `Added`: initial functional version with docs

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in include_module.gemspec
+gemspec
+
+group :test do
+  gem 'codecov', require: false
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 exAspArk
+
+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/Makefile

@@ -0,0 +1,6 @@
+.PHONY: test
+
+test:
+	bundle exec m test
+release:
+	bundle exec rake release

data/README.md

@@ -0,0 +1,278 @@
+# include_module
+
+[![Build Status](https://travis-ci.org/exAspArk/include_module.svg)](https://travis-ci.org/exAspArk/include_module)
+[![codecov](https://codecov.io/gh/exAspArk/include_module/branch/master/graph/badge.svg)](https://codecov.io/gh/exAspArk/include_module)
+[![Code Climate](https://codeclimate.com/github/exAspArk/include_module/badges/gpa.svg)](https://codeclimate.com/github/exAspArk/include_module)
+
+There are some general problems with mixins, and a lot of people complain about
+them:
+
+* [7 Patterns to Refactor Fat ActiveRecord Models](http://blog.codeclimate.com/blog/2012/10/17/7-ways-to-decompose-fat-activerecord-models/) (Ruby)
+>  Using mixins like this is akin to “cleaning” a messy room by dumping the
+>  clutter into six separate junk drawers and slamming them shut. Sure, it looks
+>  cleaner at the surface, but the junk drawers actually make it harder to
+>  identify and
+>  implement the decompositions and extractions necessary to clarify the domain
+>  model.
+
+* [Mixins considered harmful/1](http://www.artima.com/weblogs/viewpost.jsp?thread=246341) (Python)
+> Injecting methods into a class namespace is a bad idea for a very simple
+> reason: every time you use a mixin, you are actually polluting your class
+> namespace and losing track of the origin of your methods.
+
+* [Mixins Considered Harmful](https://facebook.github.io/react/blog/2016/07/13/mixins-considered-harmful.html) (JavaScript)
+> * Mixins introduce implicit dependencies
+> * Mixins cause name clashes
+> * Mixins cause snowballing complexity
+
+The **include_module** gem was created to help you to use mixing (aka `module` in Ruby)
+explicitly.
+It is a simple library with just 100 LOC, with
+zero dependencies, without any monkey patches and method overridings.
+
+## Usage
+
+There are 2 common ways to use mixins in Ruby.
+
+1) [Module.included(base)](http://ruby-doc.org/core-2.3.1/Module.html#method-i-included)
+
+```ruby
+module UserMixin
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.class_eval do
+      belongs_to :account
+    end
+  end
+
+  module ClassMethods
+    def top_user
+      User.order(rating: :desc).first
+    end
+  end
+
+  def name
+    "#{first_name} #{last_name}"
+  end
+end
+
+class User
+  include UserMixin
+end
+```
+
+This is a standard way of using mixins in Ruby. The problem here is that when
+you look at the `User` you have no idea which methods the `UserMixin`
+defines in the class.
+
+2) [ActiveSupport::Concern](http://api.rubyonrails.org/classes/ActiveSupport/Concern.html)
+
+```ruby
+module UserMixin
+  extend ActiveSupport::Concern
+
+  included do
+    belongs_to :account
+  end
+
+  class_methods do
+    def top_user
+      User.order(rating: :desc).first
+    end
+  end
+
+  def name
+    "#{first_name} #{last_name}"
+  end
+end
+
+class User
+  include UserMixin
+end
+```
+
+By extending your module, you add `.class_methods` which basically hides
+`ClassMethods` module inside, overrides `.append_features` and `.included` methods.
+Additionally it keeps tracking how many times `.included`
+was called to raise a custom exception about multiple "included" blocks.
+
+But mostly `ActiveSupport::Concern` has the same problem as standard `Module.included`.
+Why can't we define explicitly which methods we would like to use from a mixin?
+
+### **include_module**
+
+```ruby
+module UserMixin
+  INCLUDED = proc do
+    belongs_to :account
+  end
+
+  module ClassMethods
+    def top_user
+      User.order(rating: :desc).first
+    end
+  end
+
+  def name
+    "#{first_name} #{last_name}"
+  end
+end
+
+class User
+  extend IncludeModule
+
+  include_module UserMixin, included: true, class_methods: [:top_user], instance_methods: [:name]
+end
+```
+
+Now when you look at the class you can see which methods "included_module" adds in it.
+And it's all done without any monkey patches or method overridings.
+
+It is almost in-place replacement for `ActiveSupport::Concern`. Here is a diff:
+
+```ruby
+ module UserMixin
+-  extend ActiveSupport::Concern
+-
+-  included do
++  INCLUDED = proc do
+     belongs_to :account
+   end
+
+ ...
+
+ class User
++  extend IncludeModule
++
+-  include_module UserMixin
++  include_module UserMixin, included: true, class_methods: [:top_user], instance_methods: [:name]
+ end
+```
+
+You can also control which methods you would like to include, rename them
+while including in order to avoid name clashes, etc. Please see more examples below.
+
+## How Does It Work?
+
+* Include no methods
+
+When you add `extend IncludeModule`, you add just one public method called `include_module` in
+your class.
+
+```ruby
+class User
+  extend IncludeModule
+  include_module UserMixin
+end
+```
+
+By default when you call `include_module` without any options, it won't load anything.
+
+* Include all methods
+
+If you want to include everything from your module, you can pass the following options:
+
+```ruby
+class User
+  extend IncludeModule
+  include_module UserMixin, included: true, class_methods: :all, instance_methods: :all
+end
+```
+
+It will `include` you module, `extend` your `ClassMethods` and `class_eval` your
+`INCLUDED` proc without any changes.
+
+* Include some methods
+
+You can define explicitly which methods you want to include from you module:
+
+```ruby
+module TestModule
+  def foo
+    :foo
+  end
+
+  def bar
+    :bar
+  end
+end
+
+class TestClass
+  extend IncludeModule
+  include_module TestModule, instance_methods: [:foo]
+end
+```
+
+In this case we have only `TestClass#foo` method implemented.
+It basically creates a new anonymous module which contains only specified methods and includes it as usual.
+
+* Rename included method
+
+```ruby
+class User
+  extend IncludeModule
+  include_module UserMixin, instance_methods: [name: :full_name]
+end
+```
+
+We can rename methods while including a mixin by creating a new anonymous module as in the previous example.
+So `User#full_name` method will be available instead of `User#name`.
+
+## Installation
+
+Install Ruby version >= 2.1.
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'include_module'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install include_module
+
+## Development
+
+Install development dependencies:
+
+    gem install bundler
+    bundle install
+
+Run tests:
+
+    make test
+
+To release a new version, update the version number in `include_module.gemspec`,
+and then run:
+
+    make release
+
+Which will create a git tag for the version, push git commits and tags, and push
+the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## What's New?
+
+Please read the [changelog](./CHANGELOG.md).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/exAspArk/include_module.
+
+To open a pull request:
+
+1. [Fork it](https://github.com/exAspArk/include_module/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](https://github.com/exAspArk/include_module/compare)
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/include_module.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "include_module"
+  spec.version       = "0.1.0"
+  spec.authors       = ["exAspArk"]
+  spec.email         = ["exaspark@gmail.com"]
+
+  spec.summary       = %q{Include your modules explicitly}
+  spec.description   = %q{Include your modules explicitly}
+  spec.homepage      = "https://github.com/exAspArk/include_module"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '~> 2.1'
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.9"
+  spec.add_development_dependency "pry-byebug", "~> 3.4"
+  spec.add_development_dependency "m", "~> 1.5"
+end

data/lib/include_module.rb

@@ -0,0 +1,99 @@
+module IncludeModule
+  def include_module(new_module, instance_methods: [], class_methods: [], included: false)
+    if is_a?(Class)
+      __include_class_methods_in_class(new_module: new_module, method_names: class_methods)
+      __include_included_blocks_in_class(new_module: new_module, included: included)
+    else
+      __include_class_methods_in_module(new_module: new_module, method_names: class_methods)
+      __store_included_block_in_module(new_module: new_module, included: included)
+    end
+
+    __include_instance_methods(new_module: new_module, method_names: instance_methods)
+  end
+
+  private
+
+  def __include_class_methods_in_class(new_module:, method_names:)
+    return if method_names.empty?
+    class_methods_module = __class_methods_module(new_module)
+
+    if method_names == :all
+      extend class_methods_module
+    else
+      extend __map_module_instance_methods!(new_module: class_methods_module.dup, method_names: method_names)
+    end
+  end
+
+  def __include_class_methods_in_module(new_module:, method_names:)
+    return if method_names.empty?
+
+    __include_instance_methods(
+      new_module: __class_methods_module(new_module),
+      method_names: method_names,
+      include_in: __class_methods_module(self)
+    )
+  end
+
+  def __include_included_blocks_in_class(new_module:, included:)
+    return unless included
+
+    included_blocks = new_module.instance_variable_get(:@__included_blocks) || []
+    included_blocks << new_module::INCLUDED if new_module.const_defined?(:INCLUDED)
+    included_blocks.each { |included_block| class_eval(&included_block) }
+  end
+
+  def __store_included_block_in_module(new_module:, included:)
+    return unless included
+
+    @__included_blocks = new_module.instance_variable_get(:@__included_blocks) || []
+    @__included_blocks << new_module::INCLUDED if new_module.const_defined?(:INCLUDED)
+  end
+
+  def __include_instance_methods(new_module:, method_names:, include_in: self)
+    if method_names == :all
+      include_in.include(new_module)
+    else
+      new_mapped_module = __map_module_instance_methods!(new_module: new_module.dup, method_names: method_names)
+      include_in.include(new_mapped_module)
+    end
+  end
+
+  def __map_module_instance_methods!(new_module:, method_names:)
+    new_method_name_by_original_method_name = __new_method_name_by_original_method_name(method_names)
+
+    new_module.instance_methods.each do |original_method_name|
+      new_method_name = new_method_name_by_original_method_name[original_method_name]
+
+      case new_method_name
+      when original_method_name # leave it as is
+      when nil                  # remove
+        new_module.class_eval { remove_method(original_method_name) }
+      else                      # rename
+        new_module.class_eval do
+          alias_method(new_method_name, original_method_name)
+          remove_method(original_method_name)
+        end
+      end
+    end
+
+    new_module
+  end
+
+  def __new_method_name_by_original_method_name(method_names)
+    method_names.each_with_object({}) do |method_name, result|
+      if method_name.is_a?(Hash)
+        result.merge!(method_name)
+      else
+        result[method_name] = method_name
+      end
+    end
+  end
+
+  def __class_methods_module(new_module)
+    if new_module.const_defined?(:ClassMethods)
+      new_module.const_get(:ClassMethods)
+    else
+      new_module.const_set(:ClassMethods, Module.new)
+    end
+  end
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: include_module
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- exAspArk
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-08-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description: Include your modules explicitly
+email:
+- exaspark@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- Makefile
+- README.md
+- Rakefile
+- include_module.gemspec
+- lib/include_module.rb
+homepage: https://github.com/exAspArk/include_module
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Include your modules explicitly
+test_files: []