conventional_extensions 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10071e280679d17703caf2d303edbe063cd04f8899ebc40a990412f23465fe31
-  data.tar.gz: c2aca1a4cb4536d2b14e454aaca6b26c3c90c70e67b5ed59e4fe533ae9901d74
+  metadata.gz: 247b8f8bd45e5773afe0f35f6cf4210321bca59d901637f460e65381e6111711
+  data.tar.gz: 6dcf112c67bb3ec3df18ac7ff3b8c7c77b11dc513be3da153c4b825ef8de8775
 SHA512:
-  metadata.gz: de54d07c7645e960afad9ea1c23925135fa2884e0af195ec201cba7fdfe4dd66e79c1a7542d6a8db5664e0227c6b3ec3e0f201db2377bb4035610d57a66e5ea1
-  data.tar.gz: e2f06c3aefedb9d7f0fe0338876d15a4b1030c7f3bf9ab3a683bf3b11ad7c066eed8fbeca57eab5bfb47a0bbaa2c0fbd775a69f4fc44df32077cd0e02f6f928c
+  metadata.gz: 0cbb425f5eb691dcaaec2755cdd426e4950d0c26fde845739a23e663939899eb1baeb1e4ebb66f761350ada334eb67b96e0fa929671be246c1016b4a7856f983
+  data.tar.gz: 54dc95e8c7bdc679192b1ca5a2bb7e2d9deb38da220036401a9b34ed6d38e48bda24a5e1db80389ab6287d1d788d89e9f97b59fd2829ebcb86ef4fcddbbaee66

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [0.2.1] - 2022-09-07
+
+- Fixes `extend ConventionalExtensions.load_on_inherited` not finding the right directory to load extensions from. See https://github.com/kaspth/conventional_extensions/commit/1f6fe9cbf2fe44ed9d699a5dd485eaa366d875a4
+
+## [0.2.0] - 2022-08-27
+
+- Replaces the use of `::Kernel.require` with `::Kernel.load` and replaces the `$LOADED_FEATURES` tracking with an internally maintained `Set` for better Zeitwerk (Rails autoloading) inter op. See https://github.com/kaspth/conventional_extensions/pull/2
+
 ## [0.1.0] - 2022-08-27
 
 - Initial release

data/README.md

@@ -1,17 +1,19 @@
 # ConventionalExtensions
 
-ConventionalExtensions autoloads extensions to an object based on a file name convention.
+ConventionalExtensions allows splitting up class definitions based on convention, similar to `ActiveSupport::Concern`'s use.
+
+The entry point is to call `load_extensions` right after a class is originally defined:
 
 ```ruby
 # lib/post.rb
 class Post < SomeSuperclass
-  load_extensions # Will load every Ruby file under `lib/post/extensions`.
+  load_extensions # Loads every Ruby file under `lib/post/extensions/*.rb`.
 end
 ```
 
 ### Defining an extension
 
-Since the loading above happens after the `Post` constant has been defined, we can reopen the class in our extension:
+Since the loading above happens after the `Post` constant has been defined, we can reopen `Post` in an extension:
 
 ```ruby
 # lib/post/extensions/mailroom.rb
@@ -22,11 +24,11 @@ class Post # <- Post is reopened here and so there's no superclass mismatch erro
 end
 ```
 
-Now, `Post.new.mailroom` works and `Post.instance_method(:mailroom).source_location` still points to the right file and line.
+Now, `Post.new.mailroom` works and `Post.instance_method(:mailroom).source_location` points to the extension file and line.
 
 #### Defining a class method in an extension
 
-Since we're reopening the class we can also define class methods directly:
+Since we're reopening `Post` we can also define class methods directly:
 
 ```ruby
 # lib/post/extensions/cool.rb
@@ -37,9 +39,9 @@ class Post
 end
 ```
 
-Now, `Post.cool` works and `Post.method(:cool).source_location` still points to the right file and line.
+Now, `Post.cool` works and `Post.method(:cool).source_location` points to the extension file and line.
 
-Note, any class method macro extensions are available within the top-level Post definition too:
+Note, any class method macro extensions are now available within the top-level `Post` definition too:
 
 ```ruby
 # lib/post.rb
@@ -52,7 +54,7 @@ end
 
 ### Skipping class reopening boilerplate
 
-ConventionalExtensions also supports implicit class reopening so you can skip `class Post`, like so:
+ConventionalExtensions also supports implicit class reopening by automatically using `Post.class_eval` so you can skip `class Post`, like so:
 
 ```ruby
 # lib/post/extensions/mailroom.rb
@@ -61,16 +63,16 @@ def mailroom
 end
 ```
 
-With this, `Post.new.mailroom` still works and `Post.instance_method(:mailroom).source_location` still points to right file and line.
+With this, `Post.new.mailroom` still works and `Post.instance_method(:mailroom).source_location` points to the extension file and line.
 
-### Resolve dependencies with a manual `load_extensions`
+### Resolve dependencies with load hoisting
 
-In case you need to have more fine grained control over the loading, you can call `load_extensions` from within an extension:
+In case you need to have more fine grained control over the loading, you can call `load_extensions` or `load_extension` from within an extension:
 
 ```ruby
 # lib/post/extensions/mailroom.rb
 load_extension :named
-named :sup # We're depending on the class method macro from the `named` extension, and hoisting the loading.
+named :sup # We're depending on the `named` class method macro from the `named` extension, and hoisting the loading.
 
 def mailroom
   …
@@ -88,21 +90,21 @@ Whether extensions use explicit or implicit class reopening, `# frozen_string_li
 
 ### Providing a base class that expects ConventionalExtensions loading
 
-In case you're planning on setting up a base class, where you're expecting subclasses to use extensions, you can do this:
+In case you're setting up a base class, where you're expecting subclasses to use extensions, you can do:
 
 ```ruby
 class BaseClass
-  extend ConventionalExtensions.load_on_inherited # This defines the `inherited` method to auto-call `load_extensions`
+  extend ConventionalExtensions.load_on_inherited # This calls `load_extensions` automatically in the `inherited` hook.
 end
 
 class Subclass < BaseClass
-  # No need to write `load_extensions` here
+  # No need to write `load_extensions` here, it's called already.
 end
 ```
 
 ## A less boilerplate heavy alternative to `ActiveSupport::Concern` for Active Records
 
-Typically, when writing an app domain model with `ActiveSupport::Concern` you end defining an object graph like this:
+Typically, when writing an app domain model with `ActiveSupport::Concern` your object graph looks like this:
 
 ```ruby
 # app/models/post.rb
@@ -135,7 +137,7 @@ module Post::Mailroom
 end
 ```
 
-Both the `Post::Cool` and `Post::Mailroom` modules are here immediately loaded (via Zeitwerks file naming conventions) and included. More often than not they're never referred to again, so they're practically implicit modules, yet defined explicitly with a fair bit of DSL on top.
+Both `Post::Cool` and `Post::Mailroom` are immediately loaded (via Zeitwerk's file naming conventions) & included. Most often these concern modules are never referred to again, so they're practically implicit modules, yet defined with tricky DSL.
 
 With ConventionalExtensions you'd write this instead:
 
@@ -161,6 +163,10 @@ class Post
 end
 ```
 
+There are places where concerns are more suited:
+* Multi-model concerns in `app/models/concerns`, you'd need modules to help with that.
+* Needing to include multiple levels of modules and have them all inserted directly on the base class, concerns have this built in, but ConventionalExtensions can't support that. It's a rare use case nonetheless.
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:

data/lib/conventional_extensions/loader.rb

@@ -4,10 +4,8 @@ require "set"
 
 class ConventionalExtensions::Loader
   def initialize(klass, path)
-    @klass, @name = klass, klass.name
-    @directory_name = File.join path.chomp(".rb"), "extensions/"
-
-    @loaded = Set.new
+    @loaded, @klass, @matcher = Set.new, klass, /\s*class #{klass.name}/
+    @path_format = File.join File.dirname(path), underscore(klass.name), "extensions", "%s.rb"
   end
 
   def load(*extensions)
@@ -16,17 +14,23 @@ class ConventionalExtensions::Loader
   end
 
   private
+    # Logic borrowed from Active Support:
+    # https://github.com/rails/rails/blob/a2fc96a80cf26c11df3e86e86c1b2b61736af80c/activesupport/lib/active_support/inflector/methods.rb#L99
+    def underscore(name)
+      name.gsub("::", "/").tap { _1.gsub!(/([A-Z]+)(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { ($1 || $2) << "_" } }.tap(&:downcase!)
+    end
+
     def extension_paths
       Dir.glob extension_path_for("*")
     end
 
     def extension_path_for(extension)
-      @directory_name + "#{extension}.rb"
+      @path_format % extension.to_s
     end
 
     def load_one(extension)
       if @loaded.add?(extension)
-        if contents = File.read(extension) and contents.match?(/\s*class #{@name}/)
+        if contents = File.read(extension) and contents.match?(@matcher)
           ::Kernel.load extension
         else
           @klass.class_eval contents, extension, 0

data/lib/conventional_extensions/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConventionalExtensions
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/lib/conventional_extensions.rb

@@ -6,9 +6,7 @@ module ConventionalExtensions
   Object.extend self # We're enriching object itself, so any object can call `load_extensions`.
 
   def load_extensions(*extensions)
-    loader_defined_before_entrance = defined?(@loader)
-
-    @loader ||= Loader.new(self, caller_locations(1, 1).first.path)
+    @loader = Loader.new(self, Object.const_source_location(name).first) unless loader_defined_before_entrance = defined?(@loader)
     @loader.load(*extensions)
   ensure
     @loader = nil unless loader_defined_before_entrance

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: conventional_extensions
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Kasper Timm Hansen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-28 00:00:00.000000000 Z
+date: 2022-09-07 00:00:00.000000000 Z
 dependencies: []
 description:
 email: