include_module 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de37cd68ed47d17ca31835c5e3e413a66f4a9b13
-  data.tar.gz: 163712749ec437588906a13f530ff4978c02918a
+  metadata.gz: 3f098dae1198d8399acfe365f1d3ba26229306fc
+  data.tar.gz: 6e8948481ef0739e1d150210a0c8b3cb7e64a90c
 SHA512:
-  metadata.gz: 29cb5b888d56f91b354662b3e62df476ef39932bced2a5f67a060e2d68a53e8c2d80b87ee324fb966b7e8cf5d761f860853efa57cd0d019d1be2bceaed740ea3
-  data.tar.gz: 775acf4c01dcf37fb824412839259cf0cb1cd4c986bbb39daba8af0fd6e4f1b9f58b971e546443f1487f9baae4d8f7f01edaa97855c33d90f4307f823cd82d58
+  metadata.gz: 0c35479a55818b45f9218975927bc4ed7e42bcb38908ca2824503bb172d68d94e599ebd00b1c045de36470e983a9463615c7b0f0c86a8ed6a68db928ecbe890b
+  data.tar.gz: a7c6dbc6bc116a0f0f4bf87cbf2bddab021f32fe4f6a9d56877ac3902eac595601447de2f73b4f34fda97b0c4b7ca1602fe869b60d8cd8ca9079c2a5f2230cca

data/CHANGELOG.md

@@ -8,6 +8,30 @@ one of the following labels: `Added`, `Changed`, `Deprecated`,
 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)
+#### [Unreleased](https://github.com/exAspArk/include_module/compare/v1.0.0...HEAD)
 
-* `Added`: initial functional version with docs
+* WIP
+
+#### [v1.0.0](https://github.com/exAspArk/include_module/compare/v0.1.0...v1.0.0) – 2016-09-16
+
+* `Changed`: use `extend_module` for class methods:
+
+```ruby
+class Foo
+  extend IncludeModule
+  extend_module Bar::ClassMethods, methods: :all
+end
+```
+
+Instead of:
+
+```ruby
+class Foo
+  extend IncludeModule
+  include_module Bar, class_methods: :all
+end
+```
+
+#### [v0.1.0](https://github.com/exAspArk/include_module/compare/9bfa492...v0.1.0) – 2016-08-16
+
+* `Added`: initial functional version with docs.

data/README.md

@@ -27,7 +27,7 @@ them:
 
 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
+It is a simple library with just 90 LOC, with
 zero dependencies, without any monkey patches and method overridings.
 
 ## Usage
@@ -103,16 +103,16 @@ Why can't we define explicitly which methods we would like to use from a mixin?
 
 ```ruby
 module UserMixin
-  INCLUDED = proc do
-    belongs_to :account
-  end
-
   module ClassMethods
     def top_user
       User.order(rating: :desc).first
     end
   end
 
+  INCLUDED = proc do
+    belongs_to :account
+  end
+
   def name
     "#{first_name} #{last_name}"
   end
@@ -121,7 +121,8 @@ end
 class User
   extend IncludeModule
 
-  include_module UserMixin, included: true, class_methods: [:top_user], instance_methods: [:name]
+  extend_module UserMixin::ClassMethods, methods: [:top_user]
+  include_module UserMixin, included: true, methods: [:name]
 end
 ```
 
@@ -145,7 +146,8 @@ It is almost in-place replacement for `ActiveSupport::Concern`. Here is a diff:
 +  extend IncludeModule
 +
 -  include_module UserMixin
-+  include_module UserMixin, included: true, class_methods: [:top_user], instance_methods: [:name]
++  extend_module UserMixin::ClassMethods, methods: [:top_user]
++  include_module UserMixin, included: true, methods: [:name]
  end
 ```
 
@@ -156,7 +158,7 @@ while including in order to avoid name clashes, etc. Please see more examples be
 
 * Include no methods
 
-When you add `extend IncludeModule`, you add just one public method called `include_module` in
+When you add `extend IncludeModule`, you add just 2 public methods called `include_module` and `extend_module` in
 your class.
 
 ```ruby
@@ -175,7 +177,7 @@ If you want to include everything from your module, you can pass the following o
 ```ruby
 class User
   extend IncludeModule
-  include_module UserMixin, included: true, class_methods: :all, instance_methods: :all
+  include_module UserMixin, included: true, methods: :all
 end
 ```
 
@@ -199,7 +201,7 @@ end
 
 class TestClass
   extend IncludeModule
-  include_module TestModule, instance_methods: [:foo]
+  include_module TestModule, methods: [:foo]
 end
 ```
 
@@ -211,7 +213,7 @@ It basically creates a new anonymous module which contains only specified method
 ```ruby
 class User
   extend IncludeModule
-  include_module UserMixin, instance_methods: [name: :full_name]
+  include_module UserMixin, methods: [name: :full_name]
 end
 ```
 

data/include_module.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "include_module"
-  spec.version       = "0.1.0"
+  spec.version       = "1.0.0"
   spec.authors       = ["exAspArk"]
   spec.email         = ["exaspark@gmail.com"]
 

data/lib/include_module.rb

@@ -1,40 +1,32 @@
 module IncludeModule
-  def include_module(new_module, instance_methods: [], class_methods: [], included: false)
+  def extend_module(new_module, methods: [])
+    return if methods.empty?
+    __extend_methods(new_module: new_module, method_names: methods)
+  end
+
+  def include_module(new_module, 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)
+      __include_included_blocks(new_module: new_module, included: included)
+    elsif is_a?(Module)
+      __store_included_block(new_module: new_module, included: included)
     end
 
-    __include_instance_methods(new_module: new_module, method_names: instance_methods)
+    return if methods.empty?
+    __include_methods(new_module: new_module, method_names: 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)
-
+  def __extend_methods(new_module:, method_names:)
     if method_names == :all
-      extend class_methods_module
+      extend(new_module)
     else
-      extend __map_module_instance_methods!(new_module: class_methods_module.dup, method_names: method_names)
+      new_mapped_module = __map_module_methods!(new_module: new_module.dup, method_names: method_names)
+      extend(new_mapped_module)
     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:)
+  def __include_included_blocks(new_module:, included:)
     return unless included
 
     included_blocks = new_module.instance_variable_get(:@__included_blocks) || []
@@ -42,23 +34,23 @@ module IncludeModule
     included_blocks.each { |included_block| class_eval(&included_block) }
   end
 
-  def __store_included_block_in_module(new_module:, included:)
+  def __store_included_block(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)
+  def __include_methods(new_module:, method_names:)
     if method_names == :all
-      include_in.include(new_module)
+      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)
+      new_mapped_module = __map_module_methods!(new_module: new_module.dup, method_names: method_names)
+      include(new_mapped_module)
     end
   end
 
-  def __map_module_instance_methods!(new_module:, method_names:)
+  def __map_module_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|
@@ -88,12 +80,4 @@ module IncludeModule
       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

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: include_module
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - exAspArk
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-21 00:00:00.000000000 Z
+date: 2016-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -118,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Include your modules explicitly