conventional_extensions 0.1.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ae73a75b482203013f89eb32515cd611d1b198b8cedeba8681032185bf5f51a
-  data.tar.gz: 6952f8616ad0e94edab0822888d02fd881468110d0d0546ba5117ab5ec1a6d27
+  metadata.gz: 55f0ae6b450c3fb4363ce991624506d3155878b101b1547ba16dd30c339f93f1
+  data.tar.gz: 4efeba98bac400653a8ba3877da043583da29638f3e934877ae231ec8d33e15c
 SHA512:
-  metadata.gz: 9d1afc244d40c11bb184d0bbed288eac9f2f134d64e0a3957b5f7d08b69892914ba32e764c643d89c3612256e90d74888a8b31a00ad6ec48ff62068ed9f5a4c6
-  data.tar.gz: 22b5807a59e13c7a61bc7bebd6b91e7fac3617e2f3dc61d5119435c78a7a47eafc7540f46c00ca0b616f2f0151cce06300112b9df92e489b9481e9b65b874070
+  metadata.gz: 023a7134b14d0c20670fb548f4466290278f403ac9cd374b3c8b6a1ab8f58b9f8d9c7c502f599469ce8a4aeeb3288599bcb8c95b773b9b63f9c36e978a61b8d2
+  data.tar.gz: 59b476799cbe313d539b2802420b4fc938e5628dad7e59cc9f258396dcaf140d553d6db6d2c042bbd6f8c1670b3629bcc65e7c02e07e98eb817e0dc164187c54

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [0.2.2] - 2022-09-08
+
+- Fixes Zeitwerk 2.6.0 compatibility issue where extensions wouldn't load and throw an exception. See https://github.com/kaspth/conventional_extensions/commit/7fc25f1e860637e8df9fd0e81e7ca038c8c34aa0
+
+## [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/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    conventional_extensions (0.1.0)
+    conventional_extensions (0.2.2)
 
 GEM
   remote: https://rubygems.org/

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

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require "set"
+
 class ConventionalExtensions::Loader
   def initialize(klass, path)
-    @klass, @name = klass, klass.name
-    @directory_name = File.join path.match(/(?=\/extensions|\.rb)/).pre_match, "extensions/"
+    @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)
@@ -12,23 +14,27 @@ 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)
-      contents = File.read extension
-
-      case
-      when contents.match?(/\s*class #{@name}/)
-        require extension
-      when !$LOADED_FEATURES.include?(extension)
-        $LOADED_FEATURES << extension
-        @klass.class_eval contents, extension, 0
+      if @loaded.add?(extension)
+        if contents = File.read(extension) and contents.match?(@matcher)
+          ::Kernel.load extension
+        else
+          @klass.class_eval contents, extension, 0
+        end
       end
     end
 end

data/lib/conventional_extensions/version.rb

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

data/lib/conventional_extensions.rb

@@ -5,8 +5,11 @@ require_relative "conventional_extensions/version"
 module ConventionalExtensions
   Object.extend self # We're enriching object itself, so any object can call `load_extensions`.
 
-  def load_extensions(*extensions)
-    Loader.new(self, caller_locations(1, 1).first.path).load(*extensions)
+  def load_extensions(*extensions, from: Frame.previous.path)
+    @loader = Loader.new(self, from) unless loader_defined_before_entrance = defined?(@loader)
+    @loader.load(*extensions)
+  ensure
+    @loader = nil unless loader_defined_before_entrance
   end
   alias load_extension load_extensions
 
@@ -16,7 +19,13 @@ module ConventionalExtensions
   module LoadOnInherited
     def inherited(klass)
       super
-      klass.load_extensions
+      klass.load_extensions from: Frame.previous.path
+    end
+  end
+
+  module Frame
+    def self.previous
+      caller_locations(2, 1).first # Use 2 instead of 1 so we get the frame of who called us.
     end
   end
 

metadata

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