modulation 0.12 → 0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72f329f0720d40aea09237c6cce4dc9eeb5ccfd3a94d78ae7d9ce956ea016051
-  data.tar.gz: 1541fdfbef9bec5ab3b7f6ed14a5eb7445f01b9c240baaf89b77959b9e0ffcfe
+  metadata.gz: fb6a21e7962f3d8f536cae59ab3e8531c505edc64016420ac36240360d3fddd3
+  data.tar.gz: 9f8a8e67aa994e78bbb5892671adfb41fed9d900fd06d9ff9f5bb82e85af4d64
 SHA512:
-  metadata.gz: bb267ba2a1a29119346c0ccd9d001f77614945a43c4e7006b5d4900f9de9812e4afff393ec3eb7c1ffb9bf5e2ba539ef51e4811bbd203b08e66602711bb57856
-  data.tar.gz: 5fbb09abc67eaa52d345f3c9d828a46a1bcd0b77f7a36317e9d2c81e5465009bc537df80ce437c1ed64ca01e61cf1883381531206d60856a916c9a6d73562c1b
+  metadata.gz: cdffd351e444d5426028fd0c4f565323050d20f96028f11f8ace35f9e545d079ee9867e663f3f6f484f84b02b03b95930fa4c23a2c906fe1dbaf8e5cb7f93a3d
+  data.tar.gz: e63034d5b713a057a0af869ef0f2aefb91152b51790ebfd2b79cb4624065b73fbabbde295da1cf257efd3325c5d138b5640d445c921dcb2d61016f25faf18cef

data/CHANGELOG.md

@@ -1,55 +1,74 @@
-## [0.12] 2018-08-20
+0.13 2018-09-06
+---------------
 
-* Fix sanitizing of error backtrace.
-* Fix importing of gems.
+* 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.11] 2018-08-20
+0.12 2018-08-20
+---------------
 
-* Add Modulation.mock for use in testing.
+* Fix sanitizing of error backtrace
+* Fix importing of gems
 
-## [0.10] 2018-08-19
+0.11 2018-08-20
+---------------
 
-* Refactor and cleanup code.
+* Add Modulation.mock for use in testing
 
-## [0.9.1] 2018-08-15
+0.10 2018-08-19
+---------------
 
-* Small fixes to README.
+* Refactor and cleanup code
 
-## [0.9] 2018-08-13
+0.9.1 2018-08-15
+----------------
 
-* Add support for module reloading.
+* Small fixes to README
 
-## [0.8] 2018-08-05
+0.9 2018-08-13
+--------------
 
-* Add support for nested namespaces.
-* Add support for circular dependencies.
+* Add support for module reloading
 
-## [0.7] 2018-07-29
+0.8 2018-08-05
+--------------
+
+* Add support for nested namespaces
+* Add support for circular dependencies
+
+0.7 2018-07-29
+--------------
 
 * 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*
 
-## [0.5.1] 2018-07-20
+0.5.1 2018-07-20
+----------------
 
 * 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 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)
 
-## [0.3.3] 2018-07-09
+0.3.3 2018-07-09
+----------------
 
 * Switch to explicit exports
 * More documentation

data/README.md

@@ -18,41 +18,41 @@ code in a functional style, with a minimum of boilerplate code.
 
 ## Features
 
-- Provides complete isolation of each module: constant declarations in one file
-  don't leak into another.
-- Supports circular dependencies.
+- 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.
-- Allows [default exports](#default-exports) for modules exporting a single
+- Supports circular dependencies.
+- Supports [default exports](#default-exports) for modules exporting a single
   class or value.
 - Can [reload](#reloading-modules) modules at runtime without breaking your 
   code in wierd ways.
-- Supports [nested namespaces](#using-nested-namespaces) with explicit exports.
 - Allows [mocking of dependencies](#mocking-dependencies) for testing purposes.
 - Can be used to [write gems](#writing-gems-using-modulation).
 
 ## Rationale
 
-Splitting your Ruby code into multiple files loaded using `require` poses a 
-number of problems:
-
-- Once a file is `require`d, any class, module or constant in it is available 
-  to any other file in your codebase. All "globals" (classes, modules, 
-  constants) are loaded, well, globally, in a single namespace. Namespace 
-  collisions are easy in Ruby.
-- Since a `require` can appear in any file in your code, it's easy to lose
-  track of where a certain file was required and where it is used.
-- To avoid class name ocnflicts, classes need to be nested under a single 
-  hierarchical tree, sometime reaching 4 levels or more, i.e. 
-  `ActiveSupport::Messages::Rotator::Encryptor`.
+You're probably asking yourself "what the hell?" , but splitting your Ruby code
+into multiple files loaded using `require` poses a number of problems:
+
+- Once a file is `require`d, any class, module or constant in it is available
+  to any other file in your codebase. All "globals" (classes, modules,
+  constants) are loaded, well, globally, in a single namespace. Name conflicts
+  are easy in Ruby.
+- To avoid class name conflicts, classes need to be nested under a single 
+  hierarchical tree, sometime reaching 4 levels or more. Just look at Rails.
+- Since a `require`d class or module can be loaded in any file and then made
+  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 control the visibility of specific so-called globals. 
   Everything is wide-open.
 - Writing reusable functional code requires wrapping it in modules using 
-  `class << self`, `def self.foo ...` or `include Singleton`.
+  `class << self`, `def self.foo ...`, `extend self` or `include Singleton`.
 
-Personally, I have found that managing dependencies with `require` over in 
-large codebases is... not as elegant or painfree as I would expect from a 
-first-class development environment.
+Personally, I have found that managing dependencies with `require` in large
+codebases is... not as elegant or painfree as I would expect from a 
+first-class development environment. I also wanted to have a better solution
+for writing in a functional style.
 
 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 
@@ -86,7 +86,7 @@ $ gem install modulation
 
 ## Organizing your code with Modulation
 
-Modulation builds on the idea of a Ruby module as a
+Modulation builds on the idea of a Ruby `Module` as a
 ["collection of methods and constants"](https://ruby-doc.org/core-2.5.1/Module.html).
 Using modulation, any Ruby source file can be a module. Modules usually export
 method and constant declarations (usually an API for a specific, well-defined 
@@ -202,43 +202,6 @@ config = import('./config')
 db.connect(config[:host], config[:port])
 ```
 
-### Using nested namespaces
-
-Code inside modules can be further organised by separating it into nested 
-namespaces. The `export` method can be used to turn a normal nested module
-into a self-contained singleton-like object and prevent access to internal
-implementation details:
-
-*net.rb*
-```ruby
-export :Async, :TCPServer
-
-module Async
-  export :await
-
-  def await
-    Fiber.new do
-      yield Fiber.current
-      Fiber.yield
-    end
-  end
-end
-
-class TCPServer
-  ...
-  def read
-    Async.await do |fiber|
-      on(:read) {|data| fiber.resume data}
-    end
-  end
-end
-```
-
-> Note: when `export` is called inside a `module` declaration, Modulation calls
-> `extend self` implicitly, just like it does for the top-level loaded module.
-> That way there's no need to declare methods using the `def self.xxx` syntax,
-> and the module can still be used to extend arbitrary classes or objects.
-
 ### Importing methods into classes and modules
 
 Modulation provides the `extend_from` and `include_from` methods to include
@@ -264,11 +227,11 @@ end
 5.seq(:fib)
 ```
 
-### Accessing a module from nested namespaces within itself
+### Accessing a module's root namespace from nested modules within itself
 
 The special constant `MODULE` allows you to access the containing module from
-nested namespaces. This lets you call methods defined in the module's root
-namespace, or otherwise introspect the module.
+nested modules or classes. This lets you call methods defined in the module's
+root namespace, or otherwise introspect the module.
 
 ```ruby
 export :await, :MyServer
@@ -430,10 +393,10 @@ MyFeature = import 'my_gem/my_feature'
   ...
   ```
 
-## Known limitations and problems
+## Why you should not use Modulation
 
 - Modulation is (probably) not production-ready.
 - Modulation is not thread-safe.
-- Modulation probably doesn't play well with `Marshal`.
-- Modulation probably doesn't play well with code-analysis tools.
-- Modulation probably doesn't play well with rdoc/yard.
+- Modulation doesn't play well with rdoc/yard.
+- Modulation (probably) doesn't play well with `Marshal`.
+- Modulation (probably) doesn't play well with code-analysis tools.

data/bin/rbm

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'modulation'
+
+ARGV.each { |fn| import(File.expand_path(fn)) }

data/lib/modulation/builder.rb

@@ -3,138 +3,132 @@
 module Modulation
   # Implements creation of module instances
   module Builder
-    extend self
-
-    # Loads a module from file or block, wrapping it in a module facade
-    # @param info [Hash] module info
-    # @param block [Proc] module block
-    # @return [Class] module facade
-    def make(info, &block)
-      default = nil
-      mod = create(info) { |default_info| default = default_info }
-      Modulation.loaded_modules[info[:location]] = mod
-      load_module_code(mod, info, &block)
-      if default
-        set_module_default_value(default[:value], info, mod, default[:caller])
-      else
-        set_exported_symbols(mod, mod.__exported_symbols, true)
-        mod
+    class << self
+      # Loads a module from file or block, wrapping it in a module facade
+      # @param info [Hash] module info
+      # @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
+        end
       end
-    end
 
-    # Initializes a new module ready to evaluate a file module
-    # @note The given block is used to pass the value given to `export_default`
-    # @param info [Hash] module info
-    # @return [Module] new module
-    def create(info, &export_default_block)
-      Module.new.tap do |mod|
-        mod.extend(mod)
-        mod.extend(ModuleMixin)
-        mod.__module_info = info
-        mod.__export_default_block = export_default_block
-        mod.const_set(:MODULE, mod)
+      # Initializes a new module ready to evaluate a file module
+      # @note The given block is used to pass the value given to
+      # `export_default`
+      # @param info [Hash] module info
+      # @return [Module] new module
+      def create(info, &export_default_block)
+        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
-    end
 
-    # Loads a source file or a block into the given module
-    # @param mod [Module] module
-    # @param info [Hash] module info
-    # @return [void]
-    def load_module_code(mod, info, &block)
-      old_top_level_module = Modulation.top_level_module
-      Modulation.top_level_module = mod
-      if block
-        mod.module_eval(&block)
-      else
+      # Loads a source file or a block into the given module
+      # @param mod [Module] module
+      # @param info [Hash] module info
+      # @return [void]
+      def load_module_code(mod, info)
         path = info[:location]
-        mod.module_eval(IO.read(path), path)
+        mod.instance_eval(IO.read(path), path)
       end
-    ensure
-      Modulation.top_level_module = old_top_level_module
-    end
 
-    # Marks all non-exported methods as private
-    # @param mod [Module] module with exported symbols
-    # @param symbols [Array] array of exported symbols
-    # @param perform_deferred_exports [Boolean] perform deferred export flag
-    # @return [void]
-    def set_exported_symbols(mod, symbols, perform_deferred_exports = false)
-      mod.__perform_deferred_namespace_exports if perform_deferred_exports
+      # 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)
+        singleton = mod.singleton_class
 
-      mod.instance_methods.each do |sym|
-        next if symbols.include?(sym)
-        mod.send(:private, sym)
-      end
-      mod.constants.each do |sym|
-        next if sym == :MODULE || symbols.include?(sym)
-        mod.send(:private_constant, sym)
+        singleton.instance_methods(false).each do |sym|
+          next if symbols.include?(sym)
+          singleton.send(:private, sym)
+        end
+
+        singleton.constants.each do |sym|
+          next unless symbols.include?(sym)
+          mod.const_set(sym, singleton.const_get(sym))
+        end
       end
-    end
 
-    # Returns exported value for a default export
-    # If the given value is a symbol, returns the value of the corresponding
-    # constant.
-    # @param value [any] export_default value
-    # @param mod [Module] module
-    # @return [any] exported value
-    def transform_export_default_value(value, mod)
-      value.is_a?(Symbol) ? mod.const_get(value) : value
-    rescue NameError
-      value
-    end
+      # Returns exported value for a default export
+      # If the given value is a symbol, returns the value of the corresponding
+      # constant.
+      # @param value [any] export_default value
+      # @param mod [Module] module
+      # @return [any] exported value
+      def transform_export_default_value(value, mod)
+        value.is_a?(Symbol) ? mod.singleton_class.const_get(value) : value
+      rescue NameError
+        value
+      end
 
-    # Loads code for a module being reloaded, turning warnings off in order to
-    # not generate warnings upon re-assignment of constants
-    def reload_module_code(mod)
-      orig_verbose = $VERBOSE
-      $VERBOSE = nil
-      load_module_code(mod, mod.__module_info)
-    ensure
-      $VERBOSE = orig_verbose
-    end
+      # Loads code for a module being reloaded, turning warnings off in order to
+      # not generate warnings upon re-assignment of constants
+      def reload_module_code(mod)
+        orig_verbose = $VERBOSE
+        $VERBOSE = nil
+        load_module_code(mod, mod.__module_info)
+      ensure
+        $VERBOSE = orig_verbose
+      end
 
-    # Removes methods and constants from module
-    # @param mod [Module] module
-    # @return [void]
-    def cleanup_module(mod)
-      mod.constants(false).each { |c| mod.send(:remove_const, c) }
-      mod.methods(false).each { |sym| mod.send(:undef_method, sym) }
+      # Removes methods and constants from module
+      # @param mod [Module] module
+      # @return [void]
+      def cleanup_module(mod)
+        mod.constants(false).each { |c| mod.send(:remove_const, c) }
+        singleton = mod.singleton_class
+        undef_method = singleton.method(:undef_method)
 
-      private_methods = mod.private_methods(false) -
-                        Module.private_instance_methods(false)
-      private_methods.each { |sym| mod.send(:undef_method, sym) }
+        singleton.instance_methods(false).each(&undef_method)
+        singleton.private_instance_methods(false).each(&undef_method)
 
-      mod.__exported_symbols.clear
-    end
+        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'
+      # 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)
+      # 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
-      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)
+      # 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

data/lib/modulation/core.rb

@@ -6,101 +6,98 @@ module Modulation
   require_relative './builder'
   require_relative './module_mixin'
 
-  extend self
+  class << self
+    # @return [Hash] hash of loaded modules, mapping absolute paths to modules
+    attr_reader :loaded_modules
 
-  # @return [Hash] hash of loaded modules, mapping absolute paths to modules
-  attr_reader :loaded_modules
-
-  # @return [Module] currently loaded top-level module
-  attr_accessor :top_level_module
-
-  # Resets the loaded modules hash
-  def reset!
-    @loaded_modules = {}
-  end
-
-  # Show full backtrace for errors occuring while loading a module. Normally
-  # Modulation will remove stack frames occurring inside the modulation.rb code
-  # in order to make backtraces more readable when debugging.
-  def full_backtrace!
-    @full_backtrace = true
-  end
-
-  GEM_REQUIRE_ERROR_MESSAGE = <<~EOF
-    Can't import from a gem that doesn't depend on Modulation. Please use `require` instead of `import`.
-  EOF
-
-  # Imports a module from a file
-  # If the module is already loaded, returns the loaded module.
-  # @param path [String] unqualified file name
-  # @param caller_location [String] caller location
-  # @return [Module] loaded module object
-  def import(path, caller_location = caller(1..1).first)
-    abs_path = Paths.absolute_path(path, caller_location) ||
-               Paths.lookup_gem_path(path)
+    # Resets the loaded modules hash
+    def reset!
+      @loaded_modules = {}
+    end
 
-    case abs_path
-    when String
-      @loaded_modules[abs_path] || create_module_from_file(abs_path)
-    when :require_gem
-      raise_error(LoadError.new(GEM_REQUIRE_ERROR_MESSAGE), caller)
-    else
-      raise_error(LoadError.new("Module not found: #{path}"), caller)
+    # Show full backtrace for errors occuring while loading a module. Normally
+    # Modulation will remove stack frames occurring inside the modulation.rb
+    # code in order to make backtraces more readable when debugging.
+    def full_backtrace!
+      @full_backtrace = true
     end
-  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)
-  end
+    GEM_REQUIRE_ERROR_MESSAGE = <<~MSG
+      Can't import from a gem that doesn't depend on Modulation. Please use `require` instead of `import`.
+    MSG
+
+    # Imports a module from a file
+    # If the module is already loaded, returns the loaded module.
+    # @param path [String] unqualified file name
+    # @param caller_location [String] caller location
+    # @return [Module] loaded module object
+    def import(path, caller_location = caller(1..1).first)
+      abs_path = Paths.absolute_path(path, caller_location) ||
+                 Paths.lookup_gem_path(path)
+
+      case abs_path
+      when String
+        @loaded_modules[abs_path] || create_module_from_file(abs_path)
+      when :require_gem
+        raise_error(LoadError.new(GEM_REQUIRE_ERROR_MESSAGE), caller)
+      else
+        raise_error(LoadError.new("Module not found: #{path}"), caller)
+      end
+    end
 
-  # (Re-)raises an error, potentially filtering its backtrace to remove stack
-  # frames occuring in Modulation code
-  # @param error [Error] raised error
-  # @param caller [Array] error backtrace
-  # @return [void]
-  def raise_error(error, caller = error.backtrace)
-    if @full_backtrace
-      error.set_backtrace(caller)
-    else
-      error.set_backtrace(caller.reject { |l| l =~ /^#{Modulation::DIR}/ })
+    # 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)
     end
-    raise error
-  end
 
-  # Reloads the given module from its source file
-  # @param mod [Module, String] module to reload
-  # @return [Module] module
-  def reload(mod)
-    if mod.is_a?(String)
-      path = mod
-      mod = @loaded_modules[File.expand_path(mod)]
-      raise "No module loaded from #{path}" unless mod
+    # (Re-)raises an error, potentially filtering its backtrace to remove stack
+    # frames occuring in Modulation code
+    # @param error [Error] raised error
+    # @param caller [Array] error backtrace
+    # @return [void]
+    def raise_error(error, caller = error.backtrace)
+      if @full_backtrace
+        error.set_backtrace(caller)
+      else
+        error.set_backtrace(caller.reject { |l| l =~ /^#{Modulation::DIR}/ })
+      end
+      raise error
     end
 
-    Builder.cleanup_module(mod)
-    Builder.reload_module_code(mod)
+    # Reloads the given module from its source file
+    # @param mod [Module, String] module to reload
+    # @return [Module] module
+    def reload(mod)
+      if mod.is_a?(String)
+        path = mod
+        mod = @loaded_modules[File.expand_path(mod)]
+        raise "No module loaded from #{path}" unless mod
+      end
 
-    mod.tap { Builder.set_exported_symbols(mod, mod.__exported_symbols, true) }
-  end
+      Builder.cleanup_module(mod)
+      Builder.reload_module_code(mod)
+
+      mod.tap { Builder.set_exported_symbols(mod, mod.__exported_symbols) }
+    end
 
-  # Maps the given path to the given mock module, restoring the previously
-  # loaded module (if any) after calling the given block
-  # @param path [String] module path
-  # @param mod [Module] module
-  # @param caller_location [String] caller location
-  # @return [void]
-  def mock(path, mod, caller_location = caller(1..1).first)
-    path = Paths.absolute_path(path, caller_location)
-    old_module = @loaded_modules[path]
-    @loaded_modules[path] = mod
-    yield if block_given?
-  ensure
-    @loaded_modules[path] = old_module if block_given?
+    # Maps the given path to the given mock module, restoring the previously
+    # loaded module (if any) after calling the given block
+    # @param path [String] module path
+    # @param mod [Module] module
+    # @param caller_location [String] caller location
+    # @return [void]
+    def mock(path, mod, caller_location = caller(1..1).first)
+      path = Paths.absolute_path(path, caller_location)
+      old_module = @loaded_modules[path]
+      @loaded_modules[path] = mod
+      yield if block_given?
+    ensure
+      @loaded_modules[path] = old_module if block_given?
+    end
   end
 end
 

data/lib/modulation/ext.rb

@@ -13,26 +13,12 @@ end
 
 # Module extensions
 class Module
-  # Exports symbols from a namespace module declared inside an importable
-  # module. Exporting the actual symbols is deferred until the entire code
-  # has been loaded
-  # @param symbols [Array] array of symbols
-  # @return [void]
-  def export(*symbols)
-    unless Modulation.top_level_module
-      raise NameError, "Can't export symbols outside of an imported module"
-    end
-
-    extend self
-    Modulation.top_level_module.__defer_namespace_export(self, symbols)
-  end
-
   # Extends the receiver with exported methods from the given file name
   # @param path [String] module filename
   # @return [void]
   def extend_from(path)
     mod = import(path, caller(1..1).first)
-    mod.instance_methods(false).each do |sym|
+    mod.singleton_class.instance_methods(false).each do |sym|
       self.class.send(:define_method, sym, mod.method(sym).to_proc)
     end
   end
@@ -43,7 +29,7 @@ class Module
   # @return [void]
   def include_from(path)
     mod = import(path, caller(1..1).first)
-    mod.instance_methods(false).each do |sym|
+    mod.singleton_class.instance_methods(false).each do |sym|
       send(:define_method, sym, mod.method(sym).to_proc)
     end
   end

data/lib/modulation/module_mixin.rb

@@ -73,5 +73,11 @@ module Modulation
     def __exported_symbols
       @__exported_symbols ||= []
     end
+
+    # Allow modules to use attr_accessor/reader/writer and include methods by
+    # forwarding calls to singleton_class
+    [:attr_accessor, :attr_reader, :attr_writer, :include].each do |sym|
+      define_method(sym) { |*args| singleton_class.send(sym, *args) }
+    end
   end
 end

data/lib/modulation/paths.rb

@@ -3,74 +3,74 @@
 module Modulation
   # Implements methods for expanding relative or incomplete module file names
   module Paths
-    extend self
+    class << self
+      # Regexp for extracting filename from caller reference
+      CALLER_FILE_REGEXP = /^([^\:]+)\:/
 
-    # Regexp for extracting filename from caller reference
-    CALLER_FILE_REGEXP = /^([^\:]+)\:/
+      # Resolves the absolute path to the provided reference. If the file is not
+      # found, will try to resolve to a gem
+      # @param path [String] unqualified file name
+      # @param caller_location [String] caller location
+      # @return [String] absolute file name
+      def absolute_path(path, caller_location)
+        caller_file = caller_location[CALLER_FILE_REGEXP, 1]
+        return nil unless caller_file
 
-    # Resolves the absolute path to the provided reference. If the file is not
-    # found, will try to resolve to a gem
-    # @param path [String] unqualified file name
-    # @param caller_location [String] caller location
-    # @return [String] absolute file name
-    def absolute_path(path, caller_location)
-      caller_file = caller_location[CALLER_FILE_REGEXP, 1]
-      return nil unless caller_file
-
-      path = File.expand_path(path, File.dirname(caller_file))
-      check_path(path)
-    end
+        path = File.expand_path(path, File.dirname(caller_file))
+        check_path(path)
+      end
 
-    # Checks that the given path references an existing file, adding the .rb
-    # extension if needed
-    # @param path [String] absolute file path (with/without .rb extension)
-    # @return [String, nil] path of file or nil if not found
-    def check_path(path)
-      if File.file?("#{path}.rb")
-        path + '.rb'
-      elsif File.file?(path)
-        path
+      # Checks that the given path references an existing file, adding the .rb
+      # extension if needed
+      # @param path [String] absolute file path (with/without .rb extension)
+      # @return [String, nil] path of file or nil if not found
+      def check_path(path)
+        if File.file?("#{path}.rb")
+          path + '.rb'
+        elsif File.file?(path)
+          path
+        end
       end
-    end
 
-    GEM_NAME_RE = /^([^\/]+)/
+      GEM_NAME_RE = /^([^\/]+)/
 
-    # 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,
-    # returns :require_gem, which signals that the gem must be required.
-    # @param name [String] gem name
-    # @return [String, Symbol] absolute path or :require_gem
-    def lookup_gem_path(name)
-      gem = name[GEM_NAME_RE, 1] || name
-      spec = Gem::Specification.find_by_name(gem)
+      # 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,
+      # returns :require_gem, which signals that the gem must be required.
+      # @param name [String] gem name
+      # @return [String, Symbol] absolute path or :require_gem
+      def lookup_gem_path(name)
+        gem = name[GEM_NAME_RE, 1] || name
+        spec = Gem::Specification.find_by_name(gem)
 
-      if gem_uses_modulation?(spec)
-        find_gem_based_path(spec, name)
-      else
-        :require_gem
+        if gem_uses_modulation?(spec)
+          find_gem_based_path(spec, name)
+        else
+          :require_gem
+        end
+      rescue Gem::MissingSpecError
+        nil
       end
-    rescue Gem::MissingSpecError
-      nil
-    end
 
-    # Returns true if given gemspec depends on modulation, which means it can
-    # be loaded using `import`
-    # @param gemspec [Gem::Specification] gem spec
-    # @return [Boolean] does gem depend on modulation?
-    def gem_uses_modulation?(gemspec)
-      gemspec.dependencies.map(&:name).include?('modulation')
-    end
+      # Returns true if given gemspec depends on modulation, which means it can
+      # be loaded using `import`
+      # @param gemspec [Gem::Specification] gem spec
+      # @return [Boolean] does gem depend on modulation?
+      def gem_uses_modulation?(gemspec)
+        gemspec.dependencies.map(&:name).include?('modulation')
+      end
 
-    # Finds full path for gem file based on gem's require paths
-    # @param gemspec [Gem::Specification] gem spec
-    # @param path [String] given import path
-    # @return [String] full path
-    def find_gem_based_path(gemspec, path)
-      gemspec.full_require_paths.each do |p|
-        full_path = check_path(File.join(p, path))
-        return full_path if full_path
+      # Finds full path for gem file based on gem's require paths
+      # @param gemspec [Gem::Specification] gem spec
+      # @param path [String] given import path
+      # @return [String] full path
+      def find_gem_based_path(gemspec, path)
+        gemspec.full_require_paths.each do |p|
+          full_path = check_path(File.join(p, path))
+          return full_path if full_path
+        end
+        nil
       end
-      nil
     end
   end
 end

data/lib/modulation/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modulation
 version: !ruby/object:Gem::Version
-  version: '0.12'
+  version: '0.13'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-20 00:00:00.000000000 Z
+date: 2018-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -38,12 +38,15 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 4.0.1
-description: "Modulation provides an better way to organize Ruby code. Modulation
-  lets you \nexplicitly 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 declaring complex nested\nclass hierarchies.\n"
+description: |
+  Modulation provides an better way to organize 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 declaring complex nested
+  class hierarchies.
 email: ciconia@gmail.com
-executables: []
+executables:
+- rbm
 extensions: []
 extra_rdoc_files:
 - README.md
@@ -51,6 +54,7 @@ extra_rdoc_files:
 files:
 - CHANGELOG.md
 - README.md
+- bin/rbm
 - lib/modulation.rb
 - lib/modulation/builder.rb
 - lib/modulation/core.rb
@@ -58,6 +62,7 @@ files:
 - lib/modulation/gem.rb
 - lib/modulation/module_mixin.rb
 - lib/modulation/paths.rb
+- lib/modulation/version.rb
 homepage: http://github.com/ciconia/modulation
 licenses:
 - MIT