modulation 0.25 → 0.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05eb758bd8b1f020ab36975897629ae0246a181e75d63e92707aa2fb47945d46
-  data.tar.gz: f17e7568e877cfdc6d8526976f895f3595364a7755aebda382922f4bd04967d4
+  metadata.gz: 98cf3c047ad9ba16b0658581dfd6031fd5cdcfb8ce74f50aaaba490f13945216
+  data.tar.gz: '09777077cec02eb4f48d4edf9307d55226d992a096226ebeab689ae0a9e34e47'
 SHA512:
-  metadata.gz: 7db683d75d02ef37ae637727537a6403cd69d506f7c6f359be5547e5f8fb05901256fb266ce4ea41dc987fc6c0976edd4f111d1ad11335a7164790a68d4a3742
-  data.tar.gz: be5d4e4c06983e19b1921cbb256bfa8162b6aa927eb14936f2ed8dda980715f7ac85d75eee321e0f39ae1b825fcf4be0b389c5976c476f838967d970e222fca9
+  metadata.gz: 6912cf32746a94e17909a3ec05f7b7cd891c6c70e93a6ee389fae72165d058845a85dbbc482c205baa053bab16cd71b3514ed92f40a1021dd7a6918945eeb3c9
+  data.tar.gz: 02a489e032fb5451977eae9f58a8dadfba87dc073e451d712765721abfd0f20c8a69755894a7b1d72e8c5a346e216bc62979b4761f09703e4d93fb4128341b13

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+0.26 2019-08-20
+---------------
+
+* Add Module#alias_method_once for idempotent method aliasing
+* Add dependency introspection API
+* Add support for hash in `#export`
+
 0.25 2019-06-07
 ---------------
 

data/README.md

@@ -80,6 +80,7 @@ easy to understand.
   code in wierd ways.
 - Allows [mocking of dependencies](#mocking-dependencies) for testing purposes.
 - Can be used to [write gems](#writing-gems-using-modulation).
+- Module dependencies can be [introspected](#dependency-introspection).
 - Facilitates [unit-testing](#unit-testing-modules) of private methods and
   constants.
 - Can load all source files in directory at once.
@@ -144,6 +145,33 @@ Seq = import('./seq')
 puts Seq.fib(10)
 ```
 
+Another way to export methods and constants is by passing a hash to `#export`:
+
+*module.rb*
+```ruby
+export(
+  foo: :bar,
+  baz: -> { 'hello' },
+  MY_CONST: 42
+)
+
+def bar
+  :baz
+end
+```
+
+*app.rb*
+```ruby
+m = import('./module')
+m.foo #=> :baz
+m.baz #=> 'hello'
+m::MY_CONST #=> 42
+```
+
+Any capitalized key will be interpreted as a const, otherwise it will be defined
+as a method. If the value is a symbol, Modulation will look for the
+corresponding method or const definition and will treat the key as an alias.
+
 ### Importing declarations
 
 Declarations from another module can be imported using `#import`:
@@ -186,7 +214,7 @@ Groups of modules providing a uniform interface can also be loaded using
 ```ruby
 API = import_map('./math_api') #=> hash mapping filenames to modules
 API.keys #=> ['add', 'mul', 'sub', 'div']
-API['add'] #=> add module
+API['add'].(2, 2) #=> 4
 ```
 
 The `#import_map` takes an optional block to transform hash keys:
@@ -194,13 +222,13 @@ 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
+API[:add].(2, 2) #=> 4
 ```
 
-### Importing methods into classes and modules
+### Importing methods into classes and objects
 
 Modulation provides the `#extend_from` and `#include_from` methods to include
-imported methods in classes and modules:
+imported methods in classes and objects:
 
 ```ruby
 module Sequences
@@ -355,7 +383,7 @@ require 'modulation'
 
 module MockStorage
   extend self
-  
+
   def get_user(user_id)
     {
       user_id: user_id,
@@ -411,6 +439,8 @@ module SuperNet
     WebSockets: './websockets'
   )
 end
+
+SuperNet::HTTP1 #=> loads the http1 module
 ```
 
 ### Reloading modules
@@ -453,6 +483,40 @@ settings = import('settings')
 settings = settings.__reload!
 ```
 
+## Dependency introspection
+
+Modulation allows runtime introspection of dependencies between modules. You can
+interrogate a module's dependencies (i.e. the modules it imports) by calling
+`#__depedencies`:
+
+*m1.rb*
+```ruby
+import ('./m2')
+```
+
+*app.rb*
+```ruby
+m1 = import('./m1')
+m1.__depedencies #=> [<Module m2>]
+```
+
+You can also iterate over a module's entire dependency tree by using
+`#__traverse_dependencies`:
+
+```ruby
+m1 = import('./m1')
+m1.__traverse_dependencies { |mod| ... }
+```
+
+To introspect reverse dependencies (modules *using* a particular module), use
+`#__dependent_modules`:
+
+```ruby
+m1 = import('./m1')
+m1.__depedencies #=> [<Module m2>]
+m1.__dependencies.first.__dependent_modules #=> [<Module m1>]
+```
+
 ## Writing gems using Modulation
 
 Modulation can be used to write gems, providing fine-grained control over your
@@ -506,7 +570,7 @@ MyFeature = import 'my_gem/my_feature'
   require 'json'
 
   Core = import('./core')
-  
+
   ...
   ```
 

data/lib/modulation/builder.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative('exports')
+require_relative('default_export')
+
 module Modulation
   # Implements creation of module instances
   module Builder
@@ -9,15 +12,14 @@ module Modulation
       # @param block [Proc] module block
       # @return [Class] module facade
       def make(info)
-        default = nil
-        mod = create(info) { |default_info| default = default_info }
-        Modulation.loaded_modules[info[:location]] = mod
-        load_module_code(mod, info)
-        if default
-          set_module_default_value(default[:value], info, mod, default[:caller])
-        else
-          set_exported_symbols(mod, mod.__exported_symbols)
-          mod
+        # create module object
+        mod = create(info)
+        track_module_dependencies(mod) do
+          # add module to loaded modules hash
+          Modulation.loaded_modules[info[:location]] = mod
+
+          load_module_code(mod, info)
+          finalize_module_exports(info, mod)
         end
       end
 
@@ -26,16 +28,27 @@ module Modulation
       # `export_default`
       # @param info [Hash] module info
       # @return [Module] new module
-      def create(info, &export_default_block)
+      def create(info)
         Module.new.tap do |mod|
-          # mod.extend(mod)
           mod.extend(ModuleMixin)
           mod.__module_info = info
-          mod.__export_default_block = export_default_block
           mod.singleton_class.const_set(:MODULE, mod)
         end
       end
 
+      def track_module_dependencies(mod)
+        prev_module = Thread.current[:__current_module]
+        Thread.current[:__current_module] = mod
+
+        if prev_module
+          prev_module.__add_dependency(mod)
+          mod.__add_dependent_module(prev_module)
+        end
+        yield
+      ensure
+        Thread.current[:__current_module] = prev_module
+      end
+
       # Loads a source file or a block into the given module
       # @param mod [Module] module
       # @param info [Hash] module info
@@ -43,92 +56,18 @@ module Modulation
       def load_module_code(mod, info)
         path = info[:location]
         mod.instance_eval(IO.read(path), path)
+        mod.__post_load
       end
 
-      # Marks all non-exported methods as private
-      # @param mod [Module] module with exported symbols
-      # @param symbols [Array] array of exported symbols
-      # @return [void]
-      def set_exported_symbols(mod, symbols)
-        mod.__module_info[:exported_symbols] = symbols
-        singleton = mod.singleton_class
-        
-        privatize_non_exported_methods(mod, 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(mod, singleton, symbols)
-        defined_methods = singleton.instance_methods(true)
-        difference = symbols.select { |s| s=~ /^[a-z]/} - defined_methods
-        unless difference.empty?
-          raise_exported_symbol_not_found_error(difference.first, mod, :method)
-        end
-
-        singleton.instance_methods(false).each do |sym|
-          next if symbols.include?(sym)
-          singleton.send(:private, sym)
-        end
-      end
-
-      # 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)
-        defined_constants = singleton.constants(false)
-        difference = symbols.select { |s| s=~ /^[A-Z]/} - defined_constants
-        unless difference.empty?
-          raise_exported_symbol_not_found_error(difference.first, mod, :const)
-        end
-
-        private_constants = mod.__module_info[:private_constants] = []
-        defined_constants.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
-
-      NOT_FOUND_MSG = "%s %s not found in module"
-
-      def raise_exported_symbol_not_found_error(sym, mod, kind)
-        error = NameError.new(NOT_FOUND_MSG % [
-          kind == :method ? 'Method' : 'Constant',
-          sym
-        ])
-        Modulation.raise_error(error, mod.__export_backtrace)
-      end
-
-      # Returns exported value for a default export
-      # If the given value is a symbol, returns the value of the corresponding
-      # constant. If the symbol refers to a method, returns a proc enveloping
-      # the method. Raises if symbol refers to non-existent constant or method.
-      # @param value [any] export_default value
-      # @param mod [Module] module
-      # @return [any] exported value
-      def transform_export_default_value(value, mod)
-        if value.is_a?(Symbol)
-          case value
-          when /^[A-Z]/
-            if mod.singleton_class.constants(true).include?(value)
-              return mod.singleton_class.const_get(value)
-            end
-            raise_exported_symbol_not_found_error(value, mod, :const)
-          else
-            if mod.singleton_class.instance_methods(true).include?(value)
-              return proc { |*args, &block| mod.send(value, *args, &block) }
-            end
-            raise_exported_symbol_not_found_error(value, mod, :method)
-          end
+      def finalize_module_exports(info, mod)
+        if (default = mod.__export_default_info)
+          DefaultExport.set_module_default_value(
+            default[:value], info, mod, default[:caller]
+          )
+        else
+          Exports.set_exported_symbols(mod, mod.__exported_symbols)
+          mod
         end
-        value
       end
 
       # Loads code for a module being reloaded, turning warnings off in order to
@@ -136,8 +75,14 @@ module Modulation
       def reload_module_code(mod)
         orig_verbose = $VERBOSE
         $VERBOSE = nil
+        prev_module = Thread.current[:__current_module]
+        Thread.current[:__current_module] = mod
+
+        cleanup_module(mod)
         load_module_code(mod, mod.__module_info)
+        Exports.set_exported_symbols(mod, mod.__exported_symbols)
       ensure
+        Thread.current[:__current_module] = prev_module
         $VERBOSE = orig_verbose
       end
 
@@ -153,38 +98,7 @@ module Modulation
         singleton.private_instance_methods(false).each(&undef_method)
 
         mod.__exported_symbols.clear
-      end
-
-      # Error message to be displayed when trying to set a singleton value as
-      # default export
-      DEFAULT_VALUE_ERROR_MSG =
-        'Default export cannot be boolean, numeric, or symbol'
-
-      # Sets the default value for a module using export_default
-      # @param value [any] default value
-      # @param info [Hash] module info
-      # @param mod [Module] module
-      # @return [any] default value
-      def set_module_default_value(value, info, mod, caller)
-        value = transform_export_default_value(value, mod)
-        case value
-        when nil, true, false, Numeric, Symbol
-          raise(TypeError, DEFAULT_VALUE_ERROR_MSG, caller)
-        end
-        set_reload_info(value, mod.__module_info)
-        Modulation.loaded_modules[info[:location]] = value
-      end
-
-      # Adds methods for module_info and reloading to a value exported as
-      # default
-      # @param value [any] export_default value
-      # @param info [Hash] module info
-      # @return [void]
-      def set_reload_info(value, info)
-        value.define_singleton_method(:__module_info) { info }
-        value.define_singleton_method(:__reload!) do
-          Modulation::Builder.make(info)
-        end
+        mod.__reset_dependencies
       end
     end
   end

data/lib/modulation/core.rb

@@ -65,7 +65,7 @@ module Modulation
       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 = File.basename(fn) =~ /^(.+)\.rb$/ && Regexp.last_match(1)
         name = yield name, mod if block_given?
         h[name] = mod
       end
@@ -80,17 +80,14 @@ module Modulation
     def add_module_methods(mod, target, *symbols)
       methods = mod.singleton_class.instance_methods(false)
       unless symbols.empty?
-        not_exported = symbols.select { |s| s =~ /^[a-z]/ } - methods
-        unless not_exported.empty?
-          raise NameError, "symbol #{not_exported.first.inspect} not exported"
-        end
-        methods = methods & symbols
+        symbols.select! { |s| s =~ /^[a-z]/ }
+        methods = filter_exported_symbols(methods, symbols)
       end
       methods.each do |sym|
         target.send(:define_method, sym, &mod.method(sym))
       end
     end
-  
+
     # Adds all or part of a module's constants to a target object
     # If no symbols are given, all constants are added
     # @param mod [Module] imported module
@@ -100,18 +97,25 @@ module Modulation
     def add_module_constants(mod, target, *symbols)
       exported = mod.__module_info[:exported_symbols]
       unless symbols.empty?
-        not_exported = symbols.select { |s| s =~ /^[A-Z]/ } - exported
-        unless not_exported.empty?
-          raise NameError, "symbol #{not_exported.first.inspect} not exported"
-        end
-        exported = exported & symbols
+        symbols.select! { |s| s =~ /^[A-Z]/ }
+        exported = filter_exported_symbols(exported, symbols)
       end
       mod.singleton_class.constants(false).each do |sym|
         next unless exported.include?(sym)
+
         target.const_set(sym, mod.singleton_class.const_get(sym))
       end
     end
 
+    def filter_exported_symbols(exported, requested)
+      not_exported = requested - exported
+      unless not_exported.empty?
+        raise NameError, "symbol #{not_exported.first.inspect} not exported"
+      end
+
+      exported & requested
+    end
+
     # Defines a const_missing method used for auto-importing on a given object
     # @param receiver [Object] object to receive the const_missing method call
     # @param auto_import_hash [Hash] a hash mapping constant names to a source
@@ -123,7 +127,7 @@ module Modulation
         path ? const_set(sym, import(path, caller_location)) : super(sym)
       end
     end
-  
+
     # Creates a new module from a source file
     # @param path [String] source file name
     # @return [Module] module
@@ -158,10 +162,8 @@ module Modulation
         raise "No module loaded from #{path}" unless mod
       end
 
-      Builder.cleanup_module(mod)
       Builder.reload_module_code(mod)
-
-      mod.tap { Builder.set_exported_symbols(mod, mod.__exported_symbols) }
+      mod
     end
 
     # Maps the given path to the given mock module, restoring the previously

data/lib/modulation/default_export.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Modulation
+  # default export functionality
+  module DefaultExport
+    class << self
+      # Returns exported value for a default export
+      # If the given value is a symbol, returns the value of the corresponding
+      # constant. If the symbol refers to a method, returns a proc enveloping
+      # the method. Raises if symbol refers to non-existent constant or method.
+      # @param value [any] export_default value
+      # @param mod [Module] module
+      # @return [any] exported value
+      def transform_export_default_value(value, mod)
+        return value unless value.is_a?(Symbol)
+
+        case value
+        when /^[A-Z]/
+          get_module_constant(mod, value)
+        else
+          get_module_method(mod, value)
+        end
+      end
+
+      def get_module_constant(mod, value)
+        unless mod.singleton_class.constants(true).include?(value)
+          raise_exported_symbol_not_found_error(value, mod, :const)
+        end
+
+        mod.singleton_class.const_get(value)
+      end
+
+      def get_module_method(mod, value)
+        unless mod.singleton_class.instance_methods(true).include?(value)
+          raise_exported_symbol_not_found_error(value, mod, :method)
+        end
+
+        proc { |*args, &block| mod.send(value, *args, &block) }
+      end
+
+      NOT_FOUND_MSG = '%s %s not found in module'
+
+      def raise_exported_symbol_not_found_error(sym, mod, kind)
+        msg = format(
+          NOT_FOUND_MSG, kind == :method ? 'Method' : 'Constant', sym
+        )
+        error = NameError.new(msg)
+        Modulation.raise_error(error, mod.__export_backtrace)
+      end
+
+      # Error message to be displayed when trying to set a singleton value as
+      # default export
+      DEFAULT_VALUE_ERROR_MSG =
+        'Default export cannot be boolean, numeric, or symbol'
+
+      # Sets the default value for a module using export_default
+      # @param value [any] default value
+      # @param info [Hash] module info
+      # @param mod [Module] module
+      # @return [any] default value
+      def set_module_default_value(value, info, mod, caller)
+        value = transform_export_default_value(value, mod)
+        case value
+        when nil, true, false, Numeric, Symbol
+          raise(TypeError, DEFAULT_VALUE_ERROR_MSG, caller)
+        end
+        set_reload_info(value, mod.__module_info)
+        Modulation.loaded_modules[info[:location]] = value
+      end
+
+      # Adds methods for module_info and reloading to a value exported as
+      # default
+      # @param value [any] export_default value
+      # @param info [Hash] module info
+      # @return [void]
+      def set_reload_info(value, info)
+        value.define_singleton_method(:__module_info) { info }
+        value.define_singleton_method(:__reload!) do
+          Modulation::Builder.make(info)
+        end
+      end
+    end
+  end
+end

data/lib/modulation/exports.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Modulation
+  # Export functionality
+  module Exports
+    class << self
+      # Marks all non-exported methods as private
+      # @param mod [Module] module with exported symbols
+      # @param symbols [Array] array of exported symbols
+      # @return [void]
+      def set_exported_symbols(mod, symbols)
+        mod.__module_info[:exported_symbols] = symbols
+        singleton = mod.singleton_class
+
+        privatize_non_exported_methods(mod, 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(mod, singleton, symbols)
+        defined_methods = singleton.instance_methods(true)
+        difference = symbols.select { |s| s =~ /^[a-z]/ } - defined_methods
+        unless difference.empty?
+          raise_exported_symbol_not_found_error(difference.first, mod, :method)
+        end
+
+        singleton.instance_methods(false).each do |sym|
+          next if symbols.include?(sym)
+
+          singleton.send(:private, sym)
+        end
+      end
+
+      # 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)
+        defined_constants = singleton.constants(false)
+        difference = symbols.select { |s| s =~ /^[A-Z]/ } - defined_constants
+        unless difference.empty?
+          raise_exported_symbol_not_found_error(difference.first, mod, :const)
+        end
+        process_module_constants(mod, singleton, symbols, defined_constants)
+      end
+
+      def process_module_constants(mod, singleton, symbols, defined_constants)
+        private_constants = mod.__module_info[:private_constants] = []
+        defined_constants.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
+    end
+  end
+end

data/lib/modulation/ext.rb

@@ -35,13 +35,7 @@ class Module
   # @param path [String] path if sym is Symbol
   # @return [void]
   def auto_import(sym, path = nil, caller_location = caller(1..1).first)
-    unless @__auto_import_registry
-      a = @__auto_import_registry = {}
-      Modulation.define_auto_import_const_missing_method(
-        self,
-        @__auto_import_registry
-      )
-    end
+    setup_auto_import_registry unless @__auto_import_registry
     if path
       @__auto_import_registry[sym] = [path, caller_location]
     else
@@ -49,6 +43,14 @@ class Module
     end
   end
 
+  def setup_auto_import_registry
+    @__auto_import_registry = {}
+    Modulation.define_auto_import_const_missing_method(
+      self,
+      @__auto_import_registry
+    )
+  end
+
   # Extends the receiver with exported methods from the given file name
   # @param path [String] module filename
   # @return [void]
@@ -68,9 +70,20 @@ class Module
     Modulation.add_module_methods(mod, self, *symbols)
     Modulation.add_module_constants(mod, self, *symbols)
   end
+
+  # Aliases the given method only if the alias does not exist, implementing in
+  # effect idempotent method aliasing
+  # @param new_name [Symbol] alias name
+  # @param old_name [Symbol] original name
+  # @return [Module] self
+  def alias_method_once(new_name, old_name)
+    return self if method_defined?(new_name)
+
+    alias_method(new_name, old_name)
+  end
 end
 
 if Object.constants.include?(:Rake)
   Rake::DSL.alias_method :rake_import, :import
   Rake::DSL.remove_method :import
-end
+end

data/lib/modulation/module_mixin.rb

@@ -5,14 +5,58 @@ module Modulation
   module ModuleMixin
     # read and write module information
     attr_accessor :__module_info
+    attr_reader :__export_default_info
 
     # Adds given symbols to the exported_symbols array
     # @param symbols [Array] array of symbols
     # @return [void]
     def export(*symbols)
-      symbols = symbols.first if symbols.first.is_a?(Array)
-      self.__exported_symbols.concat(symbols)
-      self.__export_backtrace = caller
+      case symbols.first
+      when Hash
+        symbols = __convert_export_hash(symbols.first)
+      when Array
+        symbols = symbols.first
+      end
+
+      __exported_symbols.concat(symbols)
+      __export_backtrace = caller
+    end
+
+    def __convert_export_hash(hash)
+      @__exported_hash = hash
+      hash.keys
+    end
+
+    RE_CONST = /^[A-Z]/.freeze
+
+    def __post_load
+      return unless @__exported_hash
+
+      singleton = singleton_class
+      @__exported_hash.map do |k, v|
+        __convert_export_hash_entry(singleton, k, v)
+        k
+      end
+    end
+
+    def __convert_export_hash_entry(singleton, key, value)
+      symbol = value.is_a?(Symbol)
+      if symbol && value =~ RE_CONST && singleton.const_defined?(value)
+        value = singleton.const_get(value)
+      end
+
+      __add_exported_hash_entry(singleton, key, value, symbol)
+    end
+
+    def __add_exported_hash_entry(singleton, key, value, symbol)
+      if key =~ RE_CONST
+        singleton.const_set(key, value)
+      elsif symbol && singleton.method_defined?(value)
+        singleton.alias_method(key, value)
+      else
+        value_proc = value.is_a?(Proc) ? value : proc { value }
+        singleton.define_method(key, &value_proc)
+      end
     end
 
     # Sets a module's value, so when imported it will represent the given value,
@@ -21,7 +65,7 @@ module Modulation
     # @return [void]
     def export_default(value)
       self.__export_backtrace = caller
-      @__export_default_block&.call(value: value, caller: caller)
+      @__export_default_info = { value: value, caller: caller }
     end
 
     # Returns a text representation of the module for inspection
@@ -35,14 +79,6 @@ module Modulation
       end
     end
 
-    # Sets export_default block, used for setting the returned module object to
-    # a class or constant
-    # @param block [Proc] default export block
-    # @return [void]
-    def __export_default_block=(block)
-      @__export_default_block = block
-    end
-
     # Reload module
     # @return [Module] module
     def __reload!
@@ -80,8 +116,8 @@ module Modulation
       @__export_backtrace
     end
 
-    def __export_backtrace=(o)
-      @__export_backtrace = o
+    def __export_backtrace=(backtrace)
+      @__export_backtrace = backtrace
     end
 
     # Allow modules to use attr_accessor/reader/writer and include methods by
@@ -98,12 +134,46 @@ module Modulation
       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
+
+    def __dependencies
+      @__dependencies ||= []
+    end
+
+    def __add_dependency(mod)
+      __dependencies << mod unless __dependencies.include?(mod)
+    end
+
+    def __traverse_dependencies(&block)
+      __dependencies.each do |mod|
+        block.call mod
+        if mod.respond_to?(:__traverse_dependencies)
+          mod.__traverse_dependencies(&block)
+        end
+      end
+    end
+
+    def __dependent_modules
+      @__dependent_modules ||= []
+    end
+
+    def __add_dependent_module(mod)
+      __dependent_modules << mod unless __dependent_modules.include?(mod)
+    end
+
+    def __reset_dependencies
+      __dependencies.each do |mod|
+        next unless mod.respond_to?(:__dependent_modules)
+
+        mod.__dependent_modules.delete(self)
+      end
+      __dependencies.clear
+    end
   end
 end

data/lib/modulation/paths.rb

@@ -5,7 +5,7 @@ module Modulation
   module Paths
     class << self
       # Regexp for extracting filename from caller reference
-      CALLER_FILE_REGEXP = /^([^\:]+)\:/
+      CALLER_FILE_REGEXP = /^([^\:]+)\:/.freeze
 
       # Resolves the absolute path to the provided reference. If the file is not
       # found, will try to resolve to a gem
@@ -44,7 +44,7 @@ module Modulation
         end
       end
 
-      GEM_NAME_RE = /^([^\/]+)/
+      GEM_NAME_RE = /^([^\/]+)/.freeze
 
       # Resolves the provided path by looking for a corresponding gem. If no gem
       # is found, returns nil. If the corresponding gem does not use modulation,

data/lib/modulation/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modulation
 version: !ruby/object:Gem::Version
-  version: '0.25'
+  version: '0.26'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-07 00:00:00.000000000 Z
+date: 2019-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -56,6 +56,8 @@ files:
 - lib/modulation.rb
 - lib/modulation/builder.rb
 - lib/modulation/core.rb
+- lib/modulation/default_export.rb
+- lib/modulation/exports.rb
 - lib/modulation/ext.rb
 - lib/modulation/gem.rb
 - lib/modulation/module_mixin.rb
@@ -85,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: 'Modulation: explicit dependency management for Ruby'