modulation 1.0.1 → 1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79d44ad3050dcd57ba2c0ca917d16179197fa4ffe12e12aa7de42a050e8872c3
-  data.tar.gz: 643f1853f37b82fe0e49f62d99db0120696d5e0fa11b4d93faa5d0b9eed60070
+  metadata.gz: 2a279ab2f1b9cad5e4056290d045cd644e7637676e73bfcc8b0d6b2b737a92a2
+  data.tar.gz: 616806e62a57b0889aae801ea18d852d79fdd0e5829d45c22aa241656aa8e795
 SHA512:
-  metadata.gz: 3df78b0f925e7d2f6ddd5547c46755d51a89a76f6aba84bdd02871e456de7bdbbd1c458e46f92d7cbbd3c782b8051abfac3ace1b60853e97e7fc3694e90b3c7b
-  data.tar.gz: f7ae45414fca8d849e521efc4980e6a30b9dd1678b9f21a2b8ce438626369e77845bef4cd4be676bd67cdeb39e2b05153d9a9e5b7f9134818d7beba93280bd17
+  metadata.gz: f3bf1925ce24c315817907e8ea044a8223238bc03871ea5ada5d3368d3e4daaeae5d978a443a4fdb49ece4e8f4c7530b0dab2dfdf0731b46af63b4f2d18fa976
+  data.tar.gz: b69caae7916bac12eb51fb448dc7bab4113058643b29d558a34c0da5bbc2557744bedcecfb5939f06d7d63139c31b016a6ab52fad784e2f0242ddfc6e5784028

data/CHANGELOG.md

@@ -1,204 +1,177 @@
-1.0.1 2021-04-21
-----------------
+## 1.2 2022-11-17
 
-* Override inspect method for classes defined in modules (#7)
+- Fix `extend_from` to not extend ancestors
 
-1.0 2019-10-18
+## 1.1 2021-08-18
+
+- Add automatic `to_proc` method for callable modules
+
+## 1.0.1 2021-04-21
+
+- Override inspect method for classes defined in modules (#7)
+
+## 1.0 2019-10-18
 --------------
 
-* Cleanup code
-* Obfuscate bootstrap dictionary code in packages
-* Move packer, bootstrap, CLI, creator code into stock modules
+- Cleanup code
+- Obfuscate bootstrap dictionary code in packages
+- Move packer, bootstrap, CLI, creator code into stock modules
 
-0.34 2019-10-14
----------------
+## 0.34 2019-10-14
 
-* Improve README
+- Improve README
 
-0.33 2019-10-02
----------------
+## 0.33 2019-10-02
 
-* Add backward compatibility with Ruby 2.4.x
-* Add support for creating modules programmatically
-* Fix use of tags in import_map, auto_import_map, include_from, extend_from
+- Add backward compatibility with Ruby 2.4.x
+- Add support for creating modules programmatically
+- Fix use of tags in import_map, auto_import_map, include_from, extend_from
 
-0.32 2019-09-03
----------------
+## 0.32 2019-09-03
 
-* Implement export_from_receiver
-* Implement additive exports
-* Refactor auto_import_map, add not_found option
-* Fix backtrace for exports of missing symbols
+- Implement export_from_receiver
+- Implement additive exports
+- Refactor auto_import_map, add not_found option
+- Fix backtrace for exports of missing symbols
 
-0.31 2019-08-28
----------------
+## 0.31 2019-08-28
 
-* Fix error handling when default_export symbol is not found
+- Fix error handling when default_export symbol is not found
 
-0.30 2019-08-24
----------------
+## 0.30 2019-08-24
 
-* Add symbol_keys option to import_map
+- Add symbol_keys option to import_map
 
-0.29 2019-08-23
----------------
+## 0.29 2019-08-23
 
-* Implement auto_import_map
-* Add preliminary inline Gemfile to packaged apps
+- Implement auto_import_map
+- Add preliminary inline Gemfile to packaged apps
 
-0.28 2019-08-23
----------------
+## 0.28 2019-08-23
 
-* Implement tagged sources
-* Improve application packer
+- Implement tagged sources
+- Improve application packer
 
-0.27 2019-08-21
----------------
+## 0.27 2019-08-21
 
-* Add initial packing functionality
+- Add initial packing functionality
 
-0.26 2019-08-20
----------------
+## 0.26 2019-08-20
 
-* Add Module#alias_method_once for idempotent method aliasing
-* Add dependency introspection API
-* Add support for hash in `#export`
+- Add Module#alias_method_once for idempotent method aliasing
+- Add dependency introspection API
+- Add support for hash in `#export`
 
-0.25 2019-06-07
----------------
+## 0.25 2019-06-07
 
-* Add `#import_map` method
+- Add `#import_map` method
 
-0.24 2019-05-22
----------------
+## 0.24 2019-05-22
 
-* Fix usage of Modulation in rake tasks
-* Fix behavior when referencing missing consts in modules using `#auto_import`
+- Fix usage of Modulation in rake tasks
+- Fix behavior when referencing missing consts in modules using `#auto_import`
 
-0.23 2019-05-17
----------------
+## 0.23 2019-05-17
 
-* Fix regression in `#export_default`
+- Fix regression in `#export_default`
 
-0.22 2019-05-15
----------------
+## 0.22 2019-05-15
 
-* Export_default of a method now exports a proc calling that method
-* Raise error on export of undefined symbols
+- Export_default of a method now exports a proc calling that method
+- Raise error on export of undefined symbols
 
-0.21 2019-02-19
----------------
+## 0.21 2019-02-19
 
-* Add support for list of symbols to import in `Kernel#include_from`
+- Add support for list of symbols to import in `Kernel#include_from`
 
-0.20 2019-01-16
----------------
+## 0.20 2019-01-16
 
-* Add import_all method
+- Add import_all method
 
-0.19 2019-01-05
----------------
+## 0.19 2019-01-05
 
-* Move repo to https://github.com/digital-fabric/modulation
+- Move repo to https://github.com/digital-fabric/modulation
 
-0.18 2018-12-30
----------------
+## 0.18 2018-12-30
 
-* Add auto_import feature for lazy loading of modules
+- Add auto_import feature for lazy loading of modules
 
-0.17 2018-11-22
----------------
+## 0.17 2018-11-22
 
-* More documentation
+- More documentation
 
-0.16 2018-09-24
----------------
+## 0.16 2018-09-24
 
-* Add __expose! method for exposing private symbols for testing purposes
+- Add __expose! method for exposing private symbols for testing purposes
 
-0.15 2018-09-09
----------------
+## 0.15 2018-09-09
 
-* Fix include_from to include only exported constants
+- Fix include_from to include only exported constants
 
-0.14 2018-09-09
----------------
+## 0.14 2018-09-09
 
-* Fix include_from, extend_from to add constants to target object
+- Fix include_from, extend_from to add constants to target object
 
-0.13 2018-09-06
----------------
+## 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
----------------
+## 0.12 2018-08-20
 
-* Fix sanitizing of error backtrace
-* Fix importing of gems
+- Fix sanitizing of error backtrace
+- Fix importing of gems
 
-0.11 2018-08-20
----------------
+## 0.11 2018-08-20
 
-* Add Modulation.mock for use in testing
+- Add Modulation.mock for use in testing
 
-0.10 2018-08-19
----------------
+## 0.10 2018-08-19
 
-* Refactor and cleanup code
+- Refactor and cleanup code
 
-0.9.1 2018-08-15
-----------------
+## 0.9.1 2018-08-15
 
-* Small fixes to README
+- Small fixes to README
 
-0.9 2018-08-13
---------------
+## 0.9 2018-08-13
 
-* Add support for module reloading
+- Add support for module reloading
 
-0.8 2018-08-05
---------------
+## 0.8 2018-08-05
 
-* Add support for nested namespaces
-* Add support for circular dependencies
+- Add support for nested namespaces
+- Add support for circular dependencies
 
-0.7 2018-07-29
---------------
+## 0.7 2018-07-29
 
-* Add `MODULE` constant for accessing module from nested namespaces within itself
+- Add `MODULE` constant for accessing module from nested namespaces within itself
 
-0.6 2018-07-23
---------------
+## 0.6 2018-07-23
 
-* 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`
-* Change name to *Modulation*
+- 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`
+- Change name to *Modulation*
 
-0.5.1 2018-07-20
-----------------
+## 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
---------------
+## 0.5 2018-07-19
 
-* Add `#extend_from`, `#include_from` to include imported methods in classes
+- Add `#extend_from`, `#include_from` to include imported methods in classes
   and modules
 
-0.4 2018-07-19
---------------
+## 0.4 2018-07-19
 
-* Refactor code
-* Add tests
-* Remove namespace feature (owing to the way Ruby handles constants in blocks)
+- Refactor code
+- Add tests
+- Remove namespace feature (owing to the way Ruby handles constants in blocks)
 
-0.3.3 2018-07-09
-----------------
+## 0.3.3 2018-07-09
 
-* Switch to explicit exports
-* More documentation
-* Better error handling
+- Switch to explicit exports
+- More documentation
+- Better error handling

data/README.md

@@ -15,7 +15,7 @@
 
 
 Modulation provides an alternative way of organizing your Ruby code. Modulation
-lets you explicitly import and export declarations in order to better control 
+lets you explicitly import and export declarations in order to better control
 dependencies in your codebase. Modulation helps you refrain from littering
 the global namespace with a myriad modules, or complex multi-level nested
 module hierarchies.
@@ -25,10 +25,10 @@ from, and you'll have full control over which parts of a module's code you wish
 to expose to the outside world. Modulation can also help you write Ruby code in
 a functional style, minimizing boilerplate code.
 
-> Note: Modulation is not a replacement for RubyGems. Rather, Modulation is 
+> Note: Modulation is not a replacement for RubyGems. Rather, Modulation is
 > intended for managing dependencies between source files *inside* your Ruby
-> applications. Though it does support loading gems that were written using 
-> Modulation, it is not intended as a comprehensive solution for using 
+> applications. Though it does support loading gems that were written using
+> Modulation, it is not intended as a comprehensive solution for using
 > third-party libraries.
 
 ## Features
@@ -61,17 +61,17 @@ issues:
   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 
+- 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
   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 
+  there's `#private`, `#private_constant` etc, but by default everything is
   `#public`!
 - Extracting functionality is harder when modules are namespaced and
   dependencies are implicit.
-- Writing reusable functional code requires wrapping it in modules using 
+- 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
   [discussed](https://practicingruby.com/articles/ruby-and-the-singleton-pattern-dont-get-along)
@@ -83,7 +83,7 @@ issues:
 > "official" API.
 
 Personally, I have found that managing dependencies with `#require` in large
-codebases is... not as elegant or painfree as I would expect from a 
+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.
 
@@ -105,12 +105,12 @@ gem 'modulation'
 Modulation builds on the idea of a Ruby `Module` as a
 ["collection of methods and constants"](https://ruby-doc.org/core-2.6.5/Module.html).
 Using modulation, each Ruby source file becomes a module. Modules usually
-export method and constant declarations (usually an API for a specific, 
+export method and constant declarations (usually an API for a specific,
 well-defined functionality) to be shared with other modules. Modules can also
 import declarations from other modules. Anything not exported remains hidden
 inside the module and normally cannot be accessed from the outside.
 
-Each source file is evaluated in the context of a newly-created `Module` 
+Each source file is evaluated in the context of a newly-created `Module`
 instance, with some additional methods for introspection and miscellaneous
 operations such as [hot reloading](#reloading-modules).
 
@@ -136,7 +136,7 @@ class Session
 end
 ```
 
-A module may also expose a set of methods without using `class << self`, for 
+A module may also expose a set of methods without using `class << self`, for
 example when writing in a functional style:
 
 *seq.rb*
@@ -210,7 +210,7 @@ user = Models::User.new(...)
 ...
 ```
 
-Alternatively, a module interested in a single declaration from another module 
+Alternatively, a module interested in a single declaration from another module
 can use the following technique:
 
 ```ruby
@@ -319,7 +319,7 @@ end
 
 ### Default exports
 
-A module may wish to expose just a single class or constant, in which case it 
+A module may wish to expose just a single class or constant, in which case it
 can use `#export_default`:
 
 *user.rb*
@@ -340,7 +340,7 @@ User.new(...)
 
 The default exported value can also be defined directly thus:
 
-*config.rb* 
+*config.rb*
 ```ruby
 export_default(
   host: 'localhost',
@@ -388,7 +388,7 @@ end
 
 ### Accessing the global namespace
 
-If you need to access the global namespace inside a module just prefix the 
+If you need to access the global namespace inside a module just prefix the
 class name with double colons:
 
 ```ruby
@@ -449,7 +449,7 @@ gem called [eg](https://github.com/digital-fabric/eg/).
 ### 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 
+method. Thus you can keep implementation details hidden, while being able to
 easily test them:
 
 *parser.rb*
@@ -583,7 +583,7 @@ end
 > it without even being aware it was reloaded, providing its API has not
 > changed.
 
-Reloading of modules with default exports is also possible. Modulation will  
+Reloading of modules with default exports is also possible. Modulation will
 extend the exported value with a `#__reload!` method. The value will need to be
 reassigned:
 

data/lib/modulation/builder.rb

@@ -65,6 +65,12 @@ module Modulation
           )
         else
           Exports.perform_exports(mod)
+          if mod.respond_to?(:call) && !mod.respond_to?(:to_proc)
+            def mod.to_proc
+              method(:call).to_proc
+            end
+          end
+
           mod
         end
       end

data/lib/modulation/core.rb

@@ -40,7 +40,7 @@ module Modulation
 
       case abs_path
       when String
-        @loaded_modules[abs_path] || create_module_from_file(abs_path, caller)
+        @loaded_modules[abs_path] || import_module_from_file(abs_path, caller)
       when :require_gem
         raise_error(LoadError.new(GEM_REQUIRE_ERROR_MESSAGE), caller)
       else
@@ -49,20 +49,22 @@ module Modulation
     end
 
     # Imports all source files in given directory
-    # @ param path [String] relative directory path
+    #
+    # @param path [String] relative directory path
     # @param caller_location [String] caller location
     # @return [Array] array of module objects
     def import_all(path, caller_location = caller(CALLER_RANGE).first)
       abs_path = Paths.absolute_dir_path(path, caller_location)
       Dir["#{abs_path}/**/*.rb"].map do |fn|
-        @loaded_modules[fn] || create_module_from_file(fn, caller)
+        @loaded_modules[fn] || import_module_from_file(fn, caller)
       end
     end
 
     # Imports all source files in given directory, returning a hash mapping
-    # filenames to modules
-    # @ param path [String] relative directory path
-    # @ param options [Hash] options
+    # filenames to modules.
+    #
+    # @param path [String] relative directory path
+    # @param options [Hash] options
     # @param caller_location [String] caller location
     # @return [Hash] hash mapping filenames to modules
     def import_map(path, options = {},
@@ -70,36 +72,48 @@ module Modulation
       abs_path = Paths.absolute_dir_path(path, caller_location)
       use_symbols = options[:symbol_keys]
       Dir["#{abs_path}/*.rb"].each_with_object({}) do |fn, h|
-        mod = @loaded_modules[fn] || create_module_from_file(fn, caller)
+        mod = @loaded_modules[fn] || import_module_from_file(fn, caller)
         name = File.basename(fn) =~ /^(.+)\.rb$/ && Regexp.last_match(1)
         h[use_symbols ? name.to_sym : name] = mod
       end
     end
 
-    def auto_import_map(path, options = {},
-                        caller_location = caller(CALLER_RANGE).first)
+    # Returns a hash mapping filenames to modules, with modules being imported upon 
+    # This allows an application to load dependencies only when they are needed.
+    #
+    # @param path [String] relative directory path
+    # @param options [Hash] options
+    # @param caller_location [String] caller location
+    # @return [Hash] hash mapping filenames to modules
+    def auto_import_map(path, options = {}, caller_location = caller(CALLER_RANGE).first)
       abs_path = Paths.absolute_dir_path(path, caller_location)
       Hash.new do |h, k|
         fn = Paths.check_path(File.join(abs_path, k.to_s))
-        h[k] = find_auto_import_module(fn, path, options)
+        h[k] = find_auto_import_module(fn, options)
       end
     end
 
-    def find_auto_import_module(filename, path, options)
+    # Imports and returns the given filename. If the module does not exist,
+    # returns the value in `options[:not_found]`, otherwise raises an error.
+    #
+    # @param filename [String] filename
+    # @param options [Hash] hash of options
+    # @return [Module] imported module
+    def find_auto_import_module(filename, options)
       if filename
         return @loaded_modules[filename] ||
-               create_module_from_file(filename, caller)
+               import_module_from_file(filename, caller)
       end
 
       return options[:not_found] if options.key?(:not_found)
 
-      raise "Module not found #{path}"
+      raise "Module not found #{filename}"
     end
 
     # Creates a new module from a source file
     # @param path [String] source file name
     # @return [Module] module
-    def create_module_from_file(path, import_caller)
+    def import_module_from_file(path, import_caller)
       Builder.make(location: path, caller: import_caller)
     end
 

data/lib/modulation/ext.rb

@@ -64,7 +64,7 @@ class Module
   # @return [void]
   def extend_from(path)
     mod = import(path, caller(CALLER_RANGE).first)
-    Modulation::Builder.add_module_methods(mod, self.class)
+    Modulation::Builder.add_module_methods(mod, self.singleton_class)
     Modulation::Builder.add_module_constants(mod, self)
   end
 

data/lib/modulation/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modulation
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: '1.2'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-21 00:00:00.000000000 Z
+date: 2022-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,10 +66,12 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 4.0.1
-description: "  Modulation provides an alternative way of organizing your Ruby code.
-  Modulation\nlets you explicitly import and export declarations in order to better
-  control \ndependencies in your codebase. Modulation helps you refrain from littering\nthe
-  global namespace with a myriad modules, or complex multi-level nested\nmodule hierarchies.\n"
+description: |2
+    Modulation provides an alternative way of organizing your Ruby code. Modulation
+  lets you explicitly import and export declarations in order to better control
+  dependencies in your codebase. Modulation helps you refrain from littering
+  the global namespace with a myriad modules, or complex multi-level nested
+  module hierarchies.
 email: ciconia@gmail.com
 executables:
 - mdl
@@ -120,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: 'Modulation: explicit dependency management for Ruby'