modulation 1.1 → 1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00220ad836145e69affe04c22c0a4c699ecb68e7b5598671bf7820834572ce78
-  data.tar.gz: 0d2546469547d80482952f47ae89fed0996902419d33f51be8b529d65db6283a
+  metadata.gz: 2a279ab2f1b9cad5e4056290d045cd644e7637676e73bfcc8b0d6b2b737a92a2
+  data.tar.gz: 616806e62a57b0889aae801ea18d852d79fdd0e5829d45c22aa241656aa8e795
 SHA512:
-  metadata.gz: f56cc035c0332697d5e7a89dc46c42e880f8dcd214832ec62aa7be26f3b4d329e61cd127f064570b838b0bba768c984f4de1704570c0c79a31fc40c654d55068
-  data.tar.gz: '04894f9d7878931ae4d2adb3e51888de2e66b593638703242a8b819d681d35e608b5540c0f19f9ded9d01ba808d350360e1fd528dcc34e37e0e30abe6e027018'
+  metadata.gz: f3bf1925ce24c315817907e8ea044a8223238bc03871ea5ada5d3368d3e4daaeae5d978a443a4fdb49ece4e8f4c7530b0dab2dfdf0731b46af63b4f2d18fa976
+  data.tar.gz: b69caae7916bac12eb51fb448dc7bab4113058643b29d558a34c0da5bbc2557744bedcecfb5939f06d7d63139c31b016a6ab52fad784e2f0242ddfc6e5784028

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.2 2022-11-17
+
+- Fix `extend_from` to not extend ancestors
+
 ## 1.1 2021-08-18
 
 - Add automatic `to_proc` method for callable modules

data/README.md

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

data/lib/modulation/builder.rb

@@ -70,7 +70,7 @@ module Modulation
               method(:call).to_proc
             end
           end
-  
+
           mod
         end
       end

data/lib/modulation/core.rb

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

data/lib/modulation/ext.rb

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

data/lib/modulation/version.rb

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

metadata

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