modulation 0.31 → 1.0.1

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
@@ -55,17 +55,16 @@ module Modulation
       # @return [void]
       def load_module_code(mod, info)
         path = info[:location]
-        mod.instance_eval(info[:source] || IO.read(path), path)
-        mod.__post_load
+        mod.instance_eval(info[:source] || IO.read(path), path || '(source)')
       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
@@ -127,7 +125,7 @@ module Modulation
       def add_module_constants(mod, target, *symbols)
         exported = mod.__module_info[:exported_symbols]
         unless symbols.empty?
-          symbols.select! { |s| s =~ /^[A-Z]/ }
+          symbols.select! { |s| s =~ Modulation::RE_CONST }
           exported = filter_exported_symbols(exported, symbols)
         end
         mod.singleton_class.constants(false).each do |sym|
@@ -152,7 +150,7 @@ module Modulation
       #   file and a caller location
       # @return [void]
       def define_auto_import_const_missing_method(receiver, auto_import_hash)
-        receiver.singleton_class.define_method(:const_missing) do |sym|
+        receiver.singleton_class.send(:define_method, :const_missing) do |sym|
           (path, caller_location) = auto_import_hash[sym]
           path ? const_set(sym, import(path, caller_location)) : super(sym)
         end

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
@@ -143,6 +153,20 @@ module Modulation
     def add_tags(tags)
       Paths.add_tags(tags, caller(CALLER_RANGE).first)
     end
+
+    def create(arg = nil, &block)
+      creator = import '@modulation/creator'
+      return creator.from_block(block) if block
+
+      case arg
+      when Hash
+        creator.from_hash(arg)
+      when String
+        creator.from_string(arg)
+      else
+        raise 'Invalid argument'
+      end
+    end
   end
 end
 

data/lib/modulation/{default_export.rb → export_default.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
@@ -14,8 +14,7 @@ module Modulation
       def transform_export_default_value(value, mod)
         return value unless value.is_a?(Symbol)
 
-        case value
-        when /^[A-Z]/
+        if value =~ Modulation::RE_CONST
           get_module_constant(mod, value)
         else
           get_module_method(mod, value)
@@ -24,7 +23,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 +31,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_from_receiver.rb

@@ -0,0 +1,44 @@
+# 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.send(:define_method, m) do |*args, &block|
+            receiver.send(m, *args, &block)
+          end
+        end
+      end
+
+      RE_RESERVED_METHOD = /^__/.freeze
+
+      def receiver_methods(receiver)
+        ignored_klass = case receiver
+                        when Class, Module then receiver.class
+                        else Object
+                        end
+
+        methods = receiver.methods.reject { |m| m =~ RE_RESERVED_METHOD }
+        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
+          raise 'export_from_receiver expects a const reference'
+        end
+
+        ExportFromReceiver.from_const(mod, name)
+      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.send(: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,32 +121,45 @@ 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
 
       def process_module_constants(mod, singleton, symbols, defined_constants)
         private_constants = mod.__module_info[:private_constants] = []
         defined_constants.each do |sym|
+          next if sym == :MODULE
+
+          value = singleton.const_get(sym)
+          define_const_inspect_methods(mod, sym, value) if value.is_a?(Module)
+
           if symbols.include?(sym)
-            mod.const_set(sym, singleton.const_get(sym))
+            mod.const_set(sym, value)
           else
-            private_constants << sym unless sym == :MODULE
+            private_constants << sym
           end
         end
       end
 
+      CONST_INSPECT_CODE = <<~EOF
+        def inspect
+          "(%s)::%s"
+        end
+      EOF
+
+      def define_const_inspect_methods(mod, sym, value)
+        if value.method(:inspect).source_location.nil?
+          code = format(CONST_INSPECT_CODE, mod.inspect, sym)
+          value.singleton_class.module_eval(code)
+        end
+      end
+
       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,49 @@ 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)
-      end
+    EXPORT_DEFAULT_ERROR_MSG = <<~MSG
+      Cannot mix calls to export_from_receiver and export_default in same module
+    MSG
+
+    def export_from_receiver(name)
+      raise EXPORT_DEFAULT_ERROR_MSG if @__export_default_info
+
+      @__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 +57,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 +81,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|
@@ -152,7 +113,7 @@ module Modulation
 
     def __traverse_dependencies(&block)
       __dependencies.each do |mod|
-        block.call mod
+        block.(mod)
         if mod.respond_to?(:__traverse_dependencies)
           mod.__traverse_dependencies(&block)
         end
@@ -168,12 +129,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