modulation 0.24 → 0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ef376ed9b8358f85facdb42d47fde2c5710ccec9e20ff3bff2657e17a392327
-  data.tar.gz: 36b7033a8b9c44158f23b4bb3bc94a465bb123154d3712d79c654d237ce0061b
+  metadata.gz: 05eb758bd8b1f020ab36975897629ae0246a181e75d63e92707aa2fb47945d46
+  data.tar.gz: f17e7568e877cfdc6d8526976f895f3595364a7755aebda382922f4bd04967d4
 SHA512:
-  metadata.gz: 3b739b962bb3565c333fa8da105cc82105079494b0ec274c1d1a01ee2791407c684504291674251c9f90342705659326a2921042274a6d9708e6f481497d8470
-  data.tar.gz: dc907fc3091394365b7db34c8b0e68ac0374ecbf56e932c7a2a9bacffc9698d793a856618255730d73ed37c7ade9068c1b8e55719f09045a2c56da5d028565d9
+  metadata.gz: 7db683d75d02ef37ae637727537a6403cd69d506f7c6f359be5547e5f8fb05901256fb266ce4ea41dc987fc6c0976edd4f111d1ad11335a7164790a68d4a3742
+  data.tar.gz: be5d4e4c06983e19b1921cbb256bfa8162b6aa927eb14936f2ed8dda980715f7ac85d75eee321e0f39ae1b825fcf4be0b389c5976c476f838967d970e222fca9

data/CHANGELOG.md

@@ -1,8 +1,13 @@
+0.25 2019-06-07
+---------------
+
+* Add `#import_map` method
+
 0.24 2019-05-22
 ---------------
 
 * Fix usage of Modulation in rake tasks
-* Fix behavior when referencing missing consts in modules using `auto_import`
+* Fix behavior when referencing missing consts in modules using `#auto_import`
 
 0.23 2019-05-17
 ---------------
@@ -58,9 +63,9 @@
 0.13 2018-09-06
 ---------------
 
-* Evaluate module code on singleton_class instead of using `extend self`
-* Fix calling `include` inside imported module
-* Add `rbm` binary for running ruby scripts using `import`
+* Evaluate module code on singleton_class instead of using `#extend self`
+* Fix calling `#include` inside imported module
+* Add `rbm` binary for running ruby scripts using `#import`
 
 0.12 2018-08-20
 ---------------
@@ -103,19 +108,20 @@
 --------------
 
 * Add support for using gems as imported modules (experimental feature)
-* Add Modulation.full_trace! method for getting full backtrace on errors
-* Fix Modulation.transform_export_default_value
+* Add `Modulation.full_trace!` method for getting full backtrace on errors
+* Fix `Modulation.transform_export_default_value`
 * Change name to *Modulation*
 
 0.5.1 2018-07-20
 ----------------
 
-* Fix extend_from, include_from to work with ruby 2.4
+* Fix `#extend_from`, `#include_from` to work with ruby 2.4
 
 0.5 2018-07-19
 --------------
 
-* Add extend_from, include_from to include imported methods in classes and modules
+* Add `#extend_from`, `#include_from` to include imported methods in classes
+  and modules
 
 0.4 2018-07-19
 --------------

data/README.md

@@ -28,21 +28,21 @@ a functional style, minimizing boilerplate code.
 ## Rationale
 
 You're probably asking yourself "what the ****?" , but when your Ruby app grows
-and is split into multiple files loaded using `require`, you'll soon hit some
+and is split into multiple files loaded using `#require`, you'll soon hit some
 issues:
 
-- Once a file is `require`d, any class, module or constant in it is available
+- Once a file is `#require`d, any class, module or constant in it is available
   to any other file in your codebase. All "globals" (classes, modules,
   constants) are loaded, well, globally, in a single namespace. Name conflicts
   are easy in Ruby.
 - To avoid class name conflicts, classes need to be nested under a single 
   hierarchical tree, sometime reaching 4 levels or more. Just look at Rails.
-- Since a `require`d class or module can be loaded in any file and then made
+- Since a `#require`d class or module can be loaded in any file and then made
   available to all files, it's easy to lose track of where it was loaded, and
   where it is used.
 - There's no easy way to hide implementation-specific classes or methods. Yes,
-  there's `private`, `private_constant` etc, but by default everything is 
-  `public`!
+  there's `#private`, `#private_constant` etc, but by default everything is 
+  `#public`!
 - Writing reusable functional code requires wrapping it in modules using 
   `class << self`, `def self.foo ...`, `extend self` or `include Singleton`
   (the pain of implementing singletons in Ruby has been
@@ -54,7 +54,7 @@ issues:
 > name collision. Hopefully, the present gem could contribute to an eventual
 > "official" API.
 
-Personally, I have found that managing dependencies with `require` in large
+Personally, I have found that managing dependencies with `#require` in large
 codebases is... not as elegant or painfree as I would expect from a 
 first-class development environment. I also wanted to have a better solution
 for writing in a functional style.
@@ -108,7 +108,7 @@ operations such as [hot reloading](#reloading-modules).
 
 ### Exporting declarations
 
-Any class, module or constant be exported using `export`:
+Any class, module or constant be exported using `#export`:
 
 ```ruby
 export :User, :Session
@@ -146,7 +146,7 @@ puts Seq.fib(10)
 
 ### Importing declarations
 
-Declarations from another module can be imported using `import`:
+Declarations from another module can be imported using `#import`:
 
 ```ruby
 require 'modulation'
@@ -170,19 +170,36 @@ user = User.new(...)
 ```
 
 > **Note about paths**: module paths are always relative to the file
-> calling the `import` method, just like `require_relative`.
+> calling the `#import` method, just like `#require_relative`.
 
 ### Importing all source files in a directory
 
-To load all source files in a directory you can use `import_all`:
+To load all source files in a directory you can use `#import_all`:
 
 ```ruby
-import_all('./ext') # will load ./ext/kernel, ./ext/socket etc 
+import_all('./ext') # will load ./ext/kernel.rb, ./ext/socket.rb etc 
+```
+
+Groups of modules providing a uniform interface can also be loaded using
+`#import_map`:
+
+```ruby
+API = import_map('./math_api') #=> hash mapping filenames to modules
+API.keys #=> ['add', 'mul', 'sub', 'div']
+API['add'] #=> add module
+```
+
+The `#import_map` takes an optional block to transform hash keys:
+
+```ruby
+API = import_map('./math_api') { |name, mod| name.to_sym }
+API.keys #=> [:add, :mul, :sub, :div]
+API[:add] #=> add module
 ```
 
 ### Importing methods into classes and modules
 
-Modulation provides the `extend_from` and `include_from` methods to include
+Modulation provides the `#extend_from` and `#include_from` methods to include
 imported methods in classes and modules:
 
 ```ruby
@@ -205,7 +222,7 @@ end
 5.seq(:fib)
 ```
 
-The `include_from` method accepts an optional list of symbols to import:
+The `#include_from` method accepts an optional list of symbols to import:
 
 ```ruby
 class Integer
@@ -218,7 +235,7 @@ end
 ### Default exports
 
 A module may wish to expose just a single class or constant, in which case it 
-can use `export_default`:
+can use `#export_default`:
 
 *user.rb*
 ```ruby
@@ -295,7 +312,7 @@ what_is = ::THE_MEANING_OF_LIFE
 
 ### Unit testing modules
 
-Methods and constants that are not exported can be tested using the `__expose!`
+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:
 
@@ -380,7 +397,7 @@ end
 > lazy-loaded constant from the module's top namespace, use the `MODULE`
 > namespace, as shown above.
 
-The `auto_import` method can also take a hash mapping constant names to paths.
+The `#auto_import` method can also take a hash mapping constant names to paths.
 This is especially useful when multiple concerns are grouped under a single
 namespace:
 
@@ -440,7 +457,7 @@ settings = settings.__reload!
 
 Modulation can be used to write gems, providing fine-grained control over your
 gem's public APIs and letting you hide any implementation details. In order to
-allow loading a gem using either `require` or `import`, code your gem's main
+allow loading a gem using either `#require` or `#import`, code your gem's main
 file normally, but add  `require 'modulation/gem'` at the top, and export your
 gem's main namespace as a default export, e.g.:
 
@@ -458,7 +475,7 @@ end
 
 ## Importing gems using Modulation
 
-Gems written using modulation can also be loaded using `import`. If modulation
+Gems written using modulation can also be loaded using `#import`. If modulation
 does not find the module specified by the given relative path, it will attempt
 to load a gem by the same name. It is also possible to load specific files
 inside modules by specifying a sub-path:
@@ -468,9 +485,9 @@ require 'modulation'
 MyFeature = import 'my_gem/my_feature'
 ```
 
-> **Note**: Since there's not much of a point in `import`ing gems that do not use
-> Modulation to export symbols, Modulation will refuse to import any gem that
-> does not depend on Modulation.
+> **Note**: Since there's not much of a point in `#import`ing gems that do not
+> use Modulation to export symbols, Modulation will refuse to import any gem
+> that does not depend on Modulation.
 
 ## Coding style recommendations
 
@@ -480,8 +497,8 @@ MyFeature = import 'my_gem/my_feature'
   Settings = import('./settings')
   ```
 
-* Place your exports at the top of your module, followed by `require`s,
-  followed by `import`s:
+* Place your exports at the top of your module, followed by `#require`s,
+  followed by `#import`s:
 
   ```ruby
   export :foo, :bar, :baz

data/lib/modulation/core.rb

@@ -56,6 +56,21 @@ module Modulation
       end
     end
 
+    # Imports all source files in given directory, returning a hash mapping
+    # filenames to modules
+    # @ param path [String] relative directory path
+    # @param caller_location [String] caller location
+    # @return [Hash] hash mapping filenames to modules
+    def import_map(path, caller_location = caller(1..1).first)
+      abs_path = Paths.absolute_dir_path(path, caller_location)
+      Dir["#{abs_path}/**/*.rb"].each_with_object({}) do |fn, h|
+        mod = @loaded_modules[fn] || create_module_from_file(fn)
+        name = File.basename(fn) =~ /^(.+)\.rb$/ && $1
+        name = yield name, mod if block_given?
+        h[name] = mod
+      end
+    end
+
     # Adds all or part of a module's methods to a target object
     # If no symbols are given, all methods are added
     # @param mod [Module] imported module

data/lib/modulation/ext.rb

@@ -17,6 +17,15 @@ module Kernel
   def import_all(path, caller_location = caller(1..1).first)
     Modulation.import_all(path, caller_location)
   end
+
+  # Imports all modules in given directory, returning a hash mapping filenames
+  # to modules
+  # @param path [String] directory path
+  # @param caller_location [String] caller location
+  # @return [Hash] hash mapping filenames to module objects
+  def import_map(path, caller_location = caller(1..1).first, &block)
+    Modulation.import_map(path, caller_location, &block)
+  end
 end
 
 # Module extensions

data/lib/modulation/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modulation
 version: !ruby/object:Gem::Version
-  version: '0.24'
+  version: '0.25'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-22 00:00:00.000000000 Z
+date: 2019-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest