modulation 0.15 → 0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48d5edc681b84cf2e1c5774961f96c4e544ac0af84bbc5343e90f0fc4b1169d2
-  data.tar.gz: ac8f8ed76ae68a98dae475b9eaba677208688120dd15f4429a4d82024469409b
+  metadata.gz: 12a1828939d249c28696d296dd5f835e20f2726e101986ca2c9b1168f4fa0ff7
+  data.tar.gz: 53bdc3d0b8cf352030689930b6cf506d144e32d66187ac0a9e4cd564b1a54cfc
 SHA512:
-  metadata.gz: d1028fbba22d36fad82cc003d6958d1302479fddceafc3937f4154e81fad81ed944f487d9f44fe3afa66e4099ea73c3f5a42e73fabc5ff5ae6ef99acfe4ca7d0
-  data.tar.gz: 7c4281980fed04ed041da843fded0e555e2d00b35b7f3feb28ef3ea5ac266821b9a007212a02dbab6e67fc6adce583607a2f6b4f1e0830c17b6a530c7b896547
+  metadata.gz: 9edce0c45cbb7885ee1150b85083d2972c54d784c4fc0f74fe020d11e48d916d50eea51efdc2a6250009132186d11071013f14eb15f0e9c1bfaf75d9337a95b5
+  data.tar.gz: 6311006815093c0f15caa25b735710268303a0090bd4fbc45e9e07737d054e40956438eeefaf1431ab62bb636580b42abe7ac908a27a150679f90cbfb4316f8d

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+0.16 2018-09-24
+---------------
+
+* Add __expose! method for exposing private symbols for testing purposes
+
 0.15 2018-09-09
 ---------------
 

data/README.md

@@ -29,6 +29,7 @@ code in a functional style, with a minimum of boilerplate code.
   code in wierd ways.
 - Allows [mocking of dependencies](#mocking-dependencies) for testing purposes.
 - Can be used to [write gems](#writing-gems-using-modulation).
+- Facilitates [unit-testing](#unit-testing-modules) of private methods and constants.
 
 ## Rationale
 
@@ -266,6 +267,40 @@ end
 what = ::MEANING_OF_LIFE
 ```
 
+### Unit testing modules
+
+Methods and constants that are not exported can be tested using the `__expose!`
+method. Thus you can keep implementation details hidden, while being able to 
+easily test them:
+
+*parser.rb*
+```ruby
+export :parse
+
+def parse(inp)
+  split(inp).map(&:to_sym)
+end
+
+# private method
+def split(inp)
+  inp.split(',').map(&:strip)
+end
+```
+
+*test_seq.rb*
+```ruby
+require 'modulation'
+require 'minitest/autorun'
+
+Parser = import('../lib/parser').__expose!
+
+class FibTest < Minitest::Test
+  def test_that_split_trims_split_parts
+    assert_equal(%w[abc def ghi], Parser.split(' abc ,def , ghi  '))
+  end
+end
+```
+
 ### Mocking dependencies
 
 Modules loaded by Modulation can be easily mocked when running tests or specs,
@@ -290,8 +325,8 @@ end
 class UserControllerTest < Minitest::Test
   def test_user_storage
     Modulation.mock('../lib/storage', MockStorage) do
-      controller = UserController.
-      assert_equal
+      controller = UserController.new
+      ...
     end
   end
 end
@@ -370,32 +405,29 @@ MyFeature = import 'my_gem/my_feature'
 
 ## Coding style recommendations
 
-* Import modules into constants, not into variables:
+* Import modules into constants, not variables:
 
   ```ruby
   Settings = import('./settings')
   ```
 
-* Place your exports at the top of your module:
+* Place your exports at the top of your module, followed by `require`s,
+  followed by `import`s:
 
   ```ruby
   export :foo, :bar, :baz
 
-  ...
-  ```
-
-* Place your imports at the top of your module:
+  require 'json'
 
-  ```ruby
-  Foo = import('./foo')
-  Bar = import('./bar')
-  Baz = import('./baz')
+  Core = import('./core')
+  
   ...
   ```
 
+
 ## Why you should not use Modulation
 
-- Modulation is (probably) not production-ready.
+- Modulation is not production-ready.
 - Modulation is not thread-safe.
 - Modulation doesn't play well with rdoc/yard.
 - Modulation (probably) doesn't play well with `Marshal`.

data/lib/modulation/builder.rb

@@ -52,15 +52,35 @@ module Modulation
       def set_exported_symbols(mod, symbols)
         mod.__module_info[:exported_symbols] = symbols
         singleton = mod.singleton_class
+        
+        privatize_non_exported_methods(singleton, symbols)
+        expose_exported_constants(mod, singleton, symbols)
+      end
 
+      # Sets all non-exported methods as private for given module
+      # @param singleton [Class] sinleton for module
+      # @param symbols [Array] array of exported symbols
+      # @return [void]
+      def privatize_non_exported_methods(singleton, symbols)
         singleton.instance_methods(false).each do |sym|
           next if symbols.include?(sym)
           singleton.send(:private, sym)
         end
+      end
 
-        singleton.constants.each do |sym|
-          next unless symbols.include?(sym)
-          mod.const_set(sym, singleton.const_get(sym))
+      # Copies exported constants from singleton to module
+      # @param mod [Module] module with exported symbols
+      # @param singleton [Class] sinleton for module
+      # @param symbols [Array] array of exported symbols
+      # @return [void]
+      def expose_exported_constants(mod, singleton, symbols)
+        private_constants = mod.__module_info[:private_constants] = []
+        singleton.constants(false).each do |sym|
+          if symbols.include?(sym)
+            mod.const_set(sym, singleton.const_get(sym))
+          else
+            private_constants << sym unless sym == :MODULE
+          end
         end
       end
 

data/lib/modulation/ext.rb

@@ -18,14 +18,8 @@ class Module
   # @return [void]
   def extend_from(path)
     mod = import(path, caller(1..1).first)
-    mod.singleton_class.instance_methods(false).each do |sym|
-      self.class.send(:define_method, sym, mod.method(sym).to_proc)
-    end
-
-    mod.singleton_class.constants(false).each do |sym|
-      next if sym == :MODULE
-      const_set(sym, mod.singleton_class.const_get(sym))
-    end
+    add_module_methods(mod, self.class)
+    add_module_constants(mod, self)
   end
 
   # Includes exported methods from the given file name in the receiver
@@ -34,15 +28,21 @@ class Module
   # @return [void]
   def include_from(path)
     mod = import(path, caller(1..1).first)
-    exported_symbols = mod.__module_info[:exported_symbols]
+    add_module_methods(mod, self)
+    add_module_constants(mod, self)
+  end
 
+  def add_module_methods(mod, target)
     mod.singleton_class.instance_methods(false).each do |sym|
-      send(:define_method, sym, &mod.method(sym))
+      target.send(:define_method, sym, &mod.method(sym))
     end
+  end
 
+  def add_module_constants(mod, target)
+    exported_symbols = mod.__module_info[:exported_symbols]
     mod.singleton_class.constants(false).each do |sym|
       next unless exported_symbols.include?(sym)
-      const_set(sym, mod.singleton_class.const_get(sym))
+      target.const_set(sym, mod.singleton_class.const_get(sym))
     end
   end
 end

data/lib/modulation/module_mixin.rb

@@ -76,8 +76,24 @@ module Modulation
 
     # Allow modules to use attr_accessor/reader/writer and include methods by
     # forwarding calls to singleton_class
-    [:attr_accessor, :attr_reader, :attr_writer, :include].each do |sym|
+    %i[attr_accessor attr_reader attr_writer include].each do |sym|
       define_method(sym) { |*args| singleton_class.send(sym, *args) }
     end
+
+    # Exposes all private methods and private constants as public
+    # @return [Module] self
+    def __expose!
+      singleton = singleton_class
+
+      singleton.private_instance_methods.each do |sym|
+        singleton.send(:public, sym)
+      end
+      
+      __module_info[:private_constants].each do |sym|
+        const_set(sym, singleton.const_get(sym))
+      end
+
+      self
+    end
   end
 end

data/lib/modulation/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Modulation
-  VERSION = '0.15'
-end
+  VERSION = '0.16'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modulation
 version: !ruby/object:Gem::Version
-  version: '0.15'
+  version: '0.16'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-09 00:00:00.000000000 Z
+date: 2018-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest