modulation 0.31 → 0.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2fdd479aff209b4cf494c13fc4f7bce1ebc64c058ac6860c2dec80928b46b3b
-  data.tar.gz: 3ffce99915f23b4d1444e50c2c216e4b695f00ffdc5c5d9ff6960beb03f8fb9e
+  metadata.gz: 598679c69845dd516cf7f19ff4ae9f60e254bf488abc1460cd08b121714b4cba
+  data.tar.gz: 6b962c6f2cea4a300918eea8ff0d142999e01a32d64e7e8d814d5d15cbfb0984
 SHA512:
-  metadata.gz: 10e1497aa425b14ebabad8247f7898d45f67a255c0b88854c4eeacddaa5ffa36530425d51292f43f478e9043dc15e472a06930b9f9f9d4258e9d9651990eda6e
-  data.tar.gz: d84f11b4c5b206e30462a75307d6399492781cf5009426103e176c48aad65222c6f938468da1453755487559ae08848dc7fd641378d2167fc88f050da0d51977
+  metadata.gz: 1d8618b49710007df4312cfaefdaacc6291a7ca926945dae9378a6cb77efb0cd54947db9fe1cd84cfc8e39e9295aa22ed12db34be953f6df8eea0a072b32e596
+  data.tar.gz: ed6a9627b2e6dd89e0c3751b59362bf5b78dffb334934028aa2a8895922b64b80d79101a35f9e0ad7882fd6515d71bae87f3d1560c2f8a5d8cbe9ee856e460a2

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+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
+
 0.31 2019-08-28
 ---------------
 

data/README.md

@@ -5,6 +5,7 @@
 
 [INSTALL](#installing-modulation) |
 [GUIDE](#organizing-your-code-with-modulation) |
+[API](#api-reference) |
 [EXAMPLES](examples) |
 [RDOC](https://www.rubydoc.info/gems/modulation/)
 
@@ -27,24 +28,19 @@ a functional style, minimizing boilerplate code.
 
 ## Features
 
-- Provides complete isolation of each module: constant definitions in one file
-  do not leak into another.
-- Enforces explicit exporting and importing of methods, classes, modules and 
-  constants.
-- Supports circular dependencies.
-- Supports [default exports](#default-exports) for modules exporting a single
+- Complete isolation of each module.
+- Explicit exporting and importing of methods and constants.
+- Support for circular dependencies.
+- Support for [default exports](#default-exports) for modules exporting a single
   class or value.
-- Modules can be [lazy loaded](#lazy-loading) to improve start up time and
-  memory consumption.
-- Modules can be [reloaded](#reloading-modules) at runtime without breaking your 
-  code in wierd ways.
-- Allows [mocking of dependencies](#mocking-dependencies) for testing purposes.
+- [Lazy Loading](#lazy-loading) improves start up time and memory consumption.
+- [Hot module reloading](#reloading-modules)
+- [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
+- [Dependency introspection](#dependency-introspection).
+- Easier [unit-testing](#unit-testing-modules) of private methods and
   constants.
-- Can load all source files in directory [at once](#importing-all-source-files-in-a-directory).
-- Packs entire applications [into a single
+- Pack entire applications [into a single
   file](#packing-applications-with-modulation).
 
 ## Rationale
@@ -65,6 +61,8 @@ issues:
 - 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`!
+- Extracting functionality is harder when modules are namespaced and
+  dependencies are implicit.
 - 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
@@ -81,11 +79,10 @@ 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.
 
-So I came up with Modulation, a small gem (less than 300 LOC) that takes a 
-different approach to organizing Ruby code: any so-called global declarations 
-are hidden unless explicitly exported, and the global namespace remains 
-clutter-free. All dependencies between source files are explicit, visible, and 
-easy to understand.
+So I came up with Modulation, a small gem that takes a different approach to
+organizing Ruby code: any so-called global declarations are hidden unless
+explicitly exported, and the global namespace remains clutter-free. All
+dependencies between source files are explicit, visible, and easy to understand.
 
 ## Installing Modulation
 
@@ -109,6 +106,9 @@ 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).
 
+Modulation provides an alternative APIs for loading modules. Instead of using
+`require` and `require_relative`, you use `import`, `import_map` and other APIs.
+
 ### Exporting declarations
 
 Any class, module or constant be exported using `#export`:
@@ -174,6 +174,17 @@ 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.
 
+The `export` method can be called multiple times. Its behavior is additive:
+
+```ruby
+# this:
+export :foo, :bar
+
+# is the same as this:
+export :foo
+export :bar
+```
+
 ### Importing declarations
 
 Declarations from another module can be imported using `#import`:
@@ -690,6 +701,44 @@ end
   ...
   ```
 
+## API Reference
+
+This section will be expanded on in a future release.
+
+#### `__module_info`
+
+### `__reload!`
+
+#### `alias_method_once()`
+
+#### `auto_import()`
+
+#### `auto_import_map()`
+
+#### `export()`
+
+#### `export_default()`
+
+#### `export_from_receiver()`
+
+#### `extend_from()`
+
+#### `import()`
+
+#### `import_all()`
+
+#### `import_map()`
+
+#### `include_from()`
+
+#### `Modulation.full_backtrace!`
+
+#### `Modulation.reload()`
+
+#### `MODULE`
+
+#### `MODULE.__module_info`
+
 ## Why you should not use Modulation
 
 - Modulation is not production-ready.

data/lib/modulation/builder.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative('exports')
-require_relative('default_export')
+require_relative('export_default')
 
 module Modulation
   # Implements creation of module instances
@@ -56,16 +56,15 @@ module Modulation
       def load_module_code(mod, info)
         path = info[:location]
         mod.instance_eval(info[:source] || IO.read(path), path)
-        mod.__post_load
       end
 
       def finalize_module_exports(info, mod)
         if (default = mod.__export_default_info)
-          DefaultExport.set_module_default_value(
+          ExportDefault.set_module_default_value(
             default[:value], info, mod, default[:caller]
           )
         else
-          Exports.set_exported_symbols(mod, mod.__exported_symbols)
+          Exports.perform_exports(mod)
           mod
         end
       end
@@ -80,7 +79,7 @@ module Modulation
 
         cleanup_module(mod)
         load_module_code(mod, mod.__module_info)
-        Exports.set_exported_symbols(mod, mod.__exported_symbols)
+        Exports.perform_exports(mod)
       ensure
         Thread.current[:__current_module] = prev_module
         $VERBOSE = orig_verbose
@@ -97,8 +96,7 @@ module Modulation
         singleton.instance_methods(false).each(&undef_method)
         singleton.private_instance_methods(false).each(&undef_method)
 
-        mod.__exported_symbols.clear
-        mod.__reset_dependencies
+        mod.__before_reload
       end
 
       # Adds all or part of a module's methods to a target object

data/lib/modulation/core.rb

@@ -6,6 +6,8 @@ module Modulation
   require_relative './builder'
   require_relative './module_mixin'
 
+  RE_CONST = /^[A-Z]/.freeze
+
   class << self
     CALLER_RANGE = (1..1).freeze
 
@@ -38,7 +40,7 @@ module Modulation
 
       case abs_path
       when String
-        @loaded_modules[abs_path] || create_module_from_file(abs_path)
+        @loaded_modules[abs_path] || create_module_from_file(abs_path, caller)
       when :require_gem
         raise_error(LoadError.new(GEM_REQUIRE_ERROR_MESSAGE), caller)
       else
@@ -53,7 +55,7 @@ module Modulation
     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)
+        @loaded_modules[fn] || create_module_from_file(fn, caller)
       end
     end
 
@@ -67,8 +69,8 @@ module Modulation
                    caller_location = caller(CALLER_RANGE).first)
       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)
+      Dir["#{abs_path}/*.rb"].each_with_object({}) do |fn, h|
+        mod = @loaded_modules[fn] || create_module_from_file(fn, caller)
         name = File.basename(fn) =~ /^(.+)\.rb$/ && Regexp.last_match(1)
         h[use_symbols ? name.to_sym : name] = mod
       end
@@ -79,21 +81,26 @@ module Modulation
       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))
-        return nil unless fn
-        
-        mod = @loaded_modules[fn] || create_module_from_file(fn)
-        k = yield k, mod if block_given?
-        h[k] = mod
+        h[k] = find_auto_import_module(fn, path, options)
+      end
+    end
+
+    def find_auto_import_module(filename, path, options)
+      if filename
+        return @loaded_modules[filename] ||
+               create_module_from_file(filename, caller)
       end
+
+      return options[:not_found] if options.key?(:not_found)
+
+      raise "Module not found #{path}"
     end
 
     # Creates a new module from a source file
     # @param path [String] source file name
     # @return [Module] module
-    def create_module_from_file(path)
-      Builder.make(location: path)
-    rescue StandardError => e
-      raise_error(e)
+    def create_module_from_file(path, import_caller)
+      Builder.make(location: path, caller: import_caller)
     end
 
     # (Re-)raises an error, potentially filtering its backtrace to remove stack
@@ -104,7 +111,10 @@ module Modulation
     def raise_error(error, backtrace = nil)
       if backtrace
         unless @full_backtrace
-          backtrace = backtrace.reject { |l| l =~ /^#{Modulation::DIR}/ }
+          i = 0
+          backtrace = backtrace.reject do |l|
+            (i += 1) > 1 && l =~ /^#{Modulation::DIR}/
+          end
         end
         error.set_backtrace(backtrace)
       end

data/lib/modulation/default_export.rb

@@ -2,7 +2,7 @@
 
 module Modulation
   # default export functionality
-  module DefaultExport
+  module ExportDefault
     class << self
       # Returns exported value for a default export
       # If the given value is a symbol, returns the value of the corresponding
@@ -24,7 +24,7 @@ module Modulation
 
       def get_module_constant(mod, value)
         unless mod.singleton_class.constants(true).include?(value)
-          Exports.raise_exported_symbol_not_found_error(value, mod, :const)
+          Exports.raise_exported_symbol_not_found_error(value, :const)
         end
 
         mod.singleton_class.const_get(value)
@@ -32,7 +32,7 @@ module Modulation
 
       def get_module_method(mod, value)
         unless mod.singleton_class.instance_methods(true).include?(value)
-          Exports.raise_exported_symbol_not_found_error(value, mod, :method)
+          Exports.raise_exported_symbol_not_found_error(value, :method)
         end
 
         proc { |*args, &block| mod.send(value, *args, &block) }

data/lib/modulation/export_default.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Modulation
+  # default export functionality
+  module ExportDefault
+    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)
+          Exports.raise_exported_symbol_not_found_error(value, :const)
+        end
+
+        mod.singleton_class.const_get(value)
+      end
+
+      def get_module_method(mod, value)
+        unless mod.singleton_class.instance_methods(true).include?(value)
+          Exports.raise_exported_symbol_not_found_error(value, :method)
+        end
+
+        proc { |*args, &block| mod.send(value, *args, &block) }
+      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/export_from_receiver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Modulation
+  # Functionality related to export from receiver
+  module ExportFromReceiver
+    class << self
+      def from_const(mod, name)
+        receiver = mod.singleton_class.const_get(name)
+
+        methods = create_forwarding_methods(mod, receiver)
+        consts = copy_constants(mod, receiver)
+        methods + consts
+      end
+
+      # @return [Array] list of receiver methods
+      def create_forwarding_methods(mod, receiver)
+        receiver_methods(receiver).each do |m|
+          mod.singleton_class.define_method(m) do |*args, &block|
+            receiver.send(m, *args, &block)
+          end
+        end
+      end
+
+      def receiver_methods(receiver)
+        ignored_klass = case receiver
+                        when Class, Module then receiver.class
+                        else Object
+                        end
+        
+        methods = receiver.methods.select { |m| m !~ /^__/ }
+        methods - ignored_klass.instance_methods
+      end
+
+      # @return [Array] list of receiver constants
+      def copy_constants(mod, receiver)
+        receiver.constants(false).each do |c|
+          mod.singleton_class.const_set(c, receiver.const_get(c))
+        end
+      end
+    end
+  end
+end

data/lib/modulation/exports.rb

@@ -1,10 +1,96 @@
 # frozen_string_literal: true
 
+require_relative './export_from_receiver'
+
 module Modulation
-  # Export functionality
+  # Functionality related to symbol export
   module Exports
     class << self
-      # Marks all non-exported methods as private
+      # Performs the exporting of symbols after the module has loaded
+      def perform_exports(mod)
+        directives = mod.__export_directives
+        exported_symbols = directives.inject [] do |exported, directive|
+          symbols = export_directive mod, directive
+          exported + symbols
+        end
+        set_exported_symbols mod, exported_symbols
+      end
+
+      def export_directive(mod, directive)
+        send directive[:method], mod, *directive[:args]
+      rescue NameError => e
+        Modulation.raise_error e, directive[:export_caller]
+      end
+
+      def export(mod, *symbols)
+        case symbols.first
+        when Hash
+          symbols = export_hash(mod, symbols.first)
+        when Array
+          symbols = symbols.first
+        end
+
+        validate_exported_symbols(mod, symbols)
+        symbols
+      end
+
+      def export_from_receiver(mod, name)
+        if name =~ Modulation::RE_CONST
+          ExportFromReceiver.from_const(mod, name)
+        else
+          raise 'export_from_receiver expects a const reference'
+        end
+      end
+
+      def validate_exported_symbols(mod, symbols)
+        defined_methods = mod.singleton_class.instance_methods(true)
+        defined_constants = mod.singleton_class.constants(false)
+
+        symbols.each do |sym|
+          if sym =~ Modulation::RE_CONST
+            validate_exported_symbol(sym, defined_constants, :const)
+          else
+            validate_exported_symbol(sym, defined_methods, :method)
+          end
+        end
+      end
+
+      def validate_exported_symbol(sym, list, kind)
+        return if list.include? sym
+
+        raise_exported_symbol_not_found_error(sym, kind)
+      end
+
+      # @return [Array] array of exported symbols
+      def export_hash(mod, hash)
+        singleton = mod.singleton_class
+        hash.each { |k, v| export_hash_entry(singleton, k, v) }
+        hash.keys
+      end
+
+      def export_hash_entry(singleton, key, value)
+        symbol_value = value.is_a?(Symbol)
+        const_value = value =~ Modulation::RE_CONST
+        if value && const_value && singleton.const_defined?(value)
+          value = singleton.const_get(value)
+        end
+
+        generate_exported_hash_entry(singleton, key, value, symbol_value)
+      end
+
+      def generate_exported_hash_entry(singleton, key, value, symbol_value)
+        const_key = key =~ Modulation::RE_CONST
+        if const_key
+          singleton.const_set(key, value)
+        elsif symbol_value && 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
+
+      # Marks all non-exported methods as private, exposes exported constants
       # @param mod [Module] module with exported symbols
       # @param symbols [Array] array of exported symbols
       # @return [void]
@@ -12,7 +98,7 @@ module Modulation
         mod.__module_info[:exported_symbols] = symbols
         singleton = mod.singleton_class
 
-        privatize_non_exported_methods(mod, singleton, symbols)
+        privatize_non_exported_methods(singleton, symbols)
         expose_exported_constants(mod, singleton, symbols)
       end
 
@@ -20,13 +106,7 @@ module Modulation
       # @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
-
+      def privatize_non_exported_methods(singleton, symbols)
         singleton.instance_methods(false).each do |sym|
           next if symbols.include?(sym)
 
@@ -41,10 +121,6 @@ module Modulation
       # @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
 
@@ -61,12 +137,11 @@ module Modulation
 
       NOT_FOUND_MSG = '%s %s not found in module'
 
-      def raise_exported_symbol_not_found_error(sym, mod, kind)
+      def raise_exported_symbol_not_found_error(sym, kind)
         msg = format(
           NOT_FOUND_MSG, kind == :method ? 'Method' : 'Constant', sym
         )
-        error = NameError.new(msg)
-        Modulation.raise_error(error, mod.__export_backtrace)
+        raise NameError, msg
       end
     end
   end

data/lib/modulation/module_mixin.rb

@@ -7,56 +7,47 @@ module Modulation
     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)
-      case symbols.first
-      when Hash
-        symbols = __convert_export_hash(symbols.first)
-      when Array
-        symbols = symbols.first
-      end
-
-      __exported_symbols.concat(symbols)
-      __export_backtrace = caller
+    def __before_reload
+      @__module_info[:exported_symbols] = []
+      @__export_directives = nil
+      __reset_dependencies
     end
 
-    def __convert_export_hash(hash)
-      @__exported_hash = hash
-      hash.keys
+    def __export_directives
+      @__export_directives || []
     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
+    def __exported_symbols
+      __module_info[:exported_symbols]
     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)
+    # Adds given symbols to the exported_symbols array
+    # @param symbols [Array] array of symbols
+    # @return [void]
+    def export(*symbols)
+      if @__export_default_info
+        raise 'Cannot mix calls to export and export_default in same module'
       end
 
-      __add_exported_hash_entry(singleton, key, value, symbol)
+      @__export_directives ||= []
+      @__export_directives << {
+        method: :export,
+        args: symbols,
+        export_caller: caller
+      }
     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)
+    def export_from_receiver(name)
+      if @__export_default_info
+        raise 'Cannot mix calls to export_from_receiver and export_default in same module'
       end
+
+      @__export_directives ||= []
+      @__export_directives << {
+        method: :export_from_receiver,
+        args: name,
+        export_caller: caller
+      }
     end
 
     # Sets a module's value, so when imported it will represent the given value,
@@ -64,7 +55,10 @@ module Modulation
     # @param value [Symbol, any] symbol or value
     # @return [void]
     def export_default(value)
-      self.__export_backtrace = caller
+      unless __export_directives.empty?
+        raise 'Cannot mix calls to export and export_default in the same module'
+      end
+
       @__export_default_info = { value: value, caller: caller }
     end
 
@@ -85,41 +79,6 @@ module Modulation
       Modulation.reload(self)
     end
 
-    # Defers exporting of symbols for a namespace (nested module), to be
-    # performed after the entire module has been loaded
-    # @param namespace [Module] namespace module
-    # @param symbols [Array] array of symbols
-    # @return [void]
-    def __defer_namespace_export(namespace, symbols)
-      @__namespace_exports ||= Hash.new { |h, k| h[k] = [] }
-      @__namespace_exports[namespace].concat(symbols)
-    end
-
-    # Performs exporting of symbols for all namespaces defined in the module,
-    # marking unexported methods and constants as private
-    # @return [void]
-    def __perform_deferred_namespace_exports
-      return unless @__namespace_exports
-
-      @__namespace_exports.each do |m, symbols|
-        Builder.set_exported_symbols(m, symbols)
-      end
-    end
-
-    # Returns exported_symbols array
-    # @return [Array] array of exported symbols
-    def __exported_symbols
-      @__exported_symbols ||= []
-    end
-
-    def __export_backtrace
-      @__export_backtrace
-    end
-
-    def __export_backtrace=(backtrace)
-      @__export_backtrace = backtrace
-    end
-
     # Allow modules to use attr_accessor/reader/writer and include methods by
     # forwarding calls to singleton_class
     %i[attr_accessor attr_reader attr_writer include].each do |sym|
@@ -168,12 +127,14 @@ module Modulation
     end
 
     def __reset_dependencies
-      __dependencies.each do |mod|
+      return unless @__dependencies
+
+      @__dependencies.each do |mod|
         next unless mod.respond_to?(:__dependent_modules)
 
         mod.__dependent_modules.delete(self)
       end
-      __dependencies.clear
+      @__dependencies.clear
     end
   end
 end

data/lib/modulation/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modulation
 version: !ruby/object:Gem::Version
-  version: '0.31'
+  version: '0.32'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-28 00:00:00.000000000 Z
+date: 2019-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -57,6 +57,8 @@ files:
 - lib/modulation/builder.rb
 - lib/modulation/core.rb
 - lib/modulation/default_export.rb
+- lib/modulation/export_default.rb
+- lib/modulation/export_from_receiver.rb
 - lib/modulation/exports.rb
 - lib/modulation/ext.rb
 - lib/modulation/gem.rb