onload 1.0.5 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66e3e322ccf2b92d128fb3bf904426cff77ba86e88ec47eb8ba9c5101dd0ae28
-  data.tar.gz: 5495ff350b972c47e6c992f744245d12baa57c0929d7878241f6c9a91922f17c
+  metadata.gz: f174cf5ba8b7da4a2a70310c1adffc4a5e4b15c7f2c37cfba8a28e341b6c2c77
+  data.tar.gz: d3c95deea100141f9cb797c805361cbadc8803a3d129fdae08d4a755e5cee713
 SHA512:
-  metadata.gz: 1fd824da5c6ee8cd78342b5e0cb945353147970ebe26a4c6e16005bf8245cd5e743223441c76b7ab04216dd1757a8b3925a71b32825402d1f4becf7cbbf488c0
-  data.tar.gz: 8f296f7561c97af7ff6863a87fb73c3ef1c2bccb6379ca4aceb5300c13ccde937d17189de93e877c6016ab76a62f12225ce04e2494e77e229f59172c5dfd0de7
+  metadata.gz: c5ffdbe3816eb9c410cdb9749feb160d67a16da6be7fa7fff77a11f1a16091eb7b47e6dbd1bdd0613cb2d6524b0579cd1c0ece2b19a1ab8e33177857caa3a8fe
+  data.tar.gz: 744a1ace552ca478f69fc24cc68dbdbd42ea13e3368bf633f1c0c56b14358f5cbc7343c23d017dfee9e01808fb424655c286c3b7768dc97dbc84594578d496fc

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 1.1.1
+* Fix issues with Zeitwerk v2.8 and later.
+* Add support for Rails 8.1.
+
+## 1.1.0
+* Automatically add generated files to the specified ignore file, eg. `.gitignore`, when they are written.
+  - Specify an ignore file by setting `Onload.config.ignore_path` to the path to the ignore file you'd like to use.
+* Use appraisal-run to run tests locally for all Ruby and Rails versions.
+
 ## 1.0.5
 * Fix issues with Zeitwerk v2.7.3 and later.
 * Don't attempt to autoload directories.

data/Gemfile

@@ -9,6 +9,7 @@ end
 
 group :development do
   gem 'appraisal'
+  gem 'appraisal-run'
   gem 'benchmark-ips'
 end
 

data/README.md

@@ -46,14 +46,25 @@ Onload.install!
 
 Now, the contents of any file with a .up file extension will be passed to `UpcasePreprocessor.call`. The return value will be written to a separate Ruby file and loaded instead of the original .up file.
 
+## Ignoring Processed Files
+
+It can often be desirable to add processed/generated files to your .gitignore file. Onload comes with a mechanism that can do exactly that. Simply set the config option before running onload:
+
+```ruby
+Onload.config.ignore_path = ".gitignore"
+```
+
+Now whenever files are processed, the generated file will be automatically updated.
+
 ## Running Tests
 
-If you're using [asdf](https://asdf-vm.com/), run `./script/run_appraisal.rb` to run Rails and plain Ruby tests for all supported versions.
+Install Docker, then run `./script/run_appraisals` to run Rails and plain Ruby tests for all supported versions.
 
 Otherwise, use Appraisal to run tests for Rails or plain ruby:
 
 1. Plain ruby: `bundle exec appraisal ruby rake spec:ruby`
 1. Rails: `bundle exec appraisal <version> rake spec:rails`. Run `bundle exec appraisal list` to see the available versions. To run tests for Rails 7.0, try `bundle exec appraisal rails-7.0 rake spec:rails`
+1. Note that you must be running the correct version of Ruby specified in each gemfile.
 
 ## License
 

data/lib/onload/config.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Onload
+  class Config
+    attr_accessor :ignore_path
+
+    def initialize
+      @ignore_path = nil
+    end
+
+    def dup
+      self.class.new.tap do |duplicate|
+        duplicate.ignore_path = ignore_path.dup
+      end
+    end
+  end
+end

data/lib/onload/core_ext/kernel_zeitwerk.rb

@@ -15,18 +15,34 @@ module Kernel
       # in order to load the resulting file. Otherwise you get an error about
       # an uninitialized constant, and it's like... yeah, I _know_ it's
       # uninitialized, that's why I'm loading this file. Whatevs.
-      loader = if Zeitwerk::Registry.respond_to?(:loader_for)
+      loader = if Zeitwerk::Registry.respond_to?(:autoloads)
+        autoloads = Zeitwerk::Registry.autoloads
+
+        if autoloads.respond_to?(:registered?)
+          autoloads.registered?(file)
+        else
+          autoloads[file]
+        end
+      elsif Zeitwerk::Registry.respond_to?(:loader_for)
         Zeitwerk::Registry.loader_for(file)
-      else
-        Zeitwerk::Registry.autoloads.registered?(file)
       end
 
-      parent, cname = loader.send(:autoloads)[file]
+      autoload_entry = if loader && loader.respond_to?(:autoloads, true)
+        loader.send(:autoloads)[file]
+      end
 
-      if defined?(Zeitwerk::Cref) && parent.is_a?(Zeitwerk::Cref)
-        parent.remove
-      else
-        parent.send(:remove_const, cname)
+      if autoload_entry
+        if defined?(Zeitwerk::Cref) && autoload_entry.is_a?(Zeitwerk::Cref)
+          autoload_entry.remove
+        else
+          parent, cname = autoload_entry
+
+          if defined?(Zeitwerk::Cref) && parent.is_a?(Zeitwerk::Cref)
+            parent.remove
+          else
+            parent.send(:remove_const, cname)
+          end
+        end
       end
 
       return onload_orig_load(f.outfile, *args)

data/lib/onload/ext/zeitwerk/loader.rb

@@ -4,40 +4,63 @@ require "zeitwerk"
 require "zeitwerk/loader"
 
 module Onload
+  module ZeitwerkLoaderHelpers
+    class << self
+      def method_exists?(method_name)
+        Zeitwerk::Loader.method_defined?(method_name) ||
+          Zeitwerk::Loader.private_method_defined?(method_name)
+      end
+    end
+  end
+
   module ZeitwerkLoaderPatch
     private
 
-    def ruby?(path)
-      super || Onload.process?(path)
+    if Onload::ZeitwerkLoaderHelpers.method_exists?(:ruby?)
+      def ruby?(path)
+        super || Onload.process?(path)
+      end
     end
 
-    if Zeitwerk::Loader.instance_method(:autoload_file).arity == 2
-      def autoload_file(cref, file)
-        if !Onload.process?(file)
-          if (unprocessed_file = Onload.unprocessed_file_for(file))
-            file = unprocessed_file
+    if Onload::ZeitwerkLoaderHelpers.method_exists?(:autoload_file)
+      if Zeitwerk::Loader.instance_method(:autoload_file).arity == 2
+        def autoload_file(cref, file)
+          if !Onload.process?(file)
+            if (unprocessed_file = Onload.unprocessed_file_for(file))
+              file = unprocessed_file
+            end
           end
+
+          super
         end
+      else
+        def autoload_file(parent, cname, file)
+          if Onload.process?(file)
+            # Some older versions of Zeitwerk very naively try to remove only the
+            # last 3 characters in an attempt to strip off the .rb file extension,
+            # while newer ones only remove it if it's actually there. This line is
+            # necessary to remove the trailing leftover period for older versions,
+            # and remove the entire extension for newer versions. Although cname
+            # means "constant name," we use Onload.basename to remove all residual
+            # file extensions that were left over from the conversion from a file
+            # name to a cname.
+            cname = Onload.basename(cname.to_s).to_sym
+          else
+            # if there is a corresponding unprocessed file, autoload it instead of
+            # the .rb file
+            if (unprocessed_file = Onload.unprocessed_file_for(file))
+              file = unprocessed_file
+            end
+          end
 
-        super
+          super
+        end
       end
-    else
-      def autoload_file(parent, cname, file)
-        if Onload.process?(file)
-          # Some older versions of Zeitwerk very naïvely try to remove only the
-          # last 3 characters in an attempt to strip off the .rb file extension,
-          # while newer ones only remove it if it's actually there. This line is
-          # necessary to remove the trailing leftover period for older versions,
-          # and remove the entire extension for newer versions. Although cname
-          # means "constant name," we use Onload.basename to remove all residual
-          # file extensions that were left over from the conversion from a file
-          # name to a cname.
-          cname = Onload.basename(cname.to_s).to_sym
-        else
-          # if there is a corresponding unprocessed file, autoload it instead of
-          # the .rb file
-          if (unprocessed_file = Onload.unprocessed_file_for(file))
-            file = unprocessed_file
+    elsif Onload::ZeitwerkLoaderHelpers.method_exists?(:define_autoload)
+      def define_autoload(cref, abspath)
+        if !::File.directory?(abspath) && !Onload.process?(abspath)
+          if (unprocessed_file = Onload.unprocessed_file_for(abspath))
+            abspath = unprocessed_file
           end
         end
 
@@ -45,15 +68,23 @@ module Onload
       end
     end
 
-    # introduced in Zeitwerk v2.6.10
-    def cname_for(basename, abspath)
-      super(Onload.basename(basename), abspath)
+    if Onload::ZeitwerkLoaderHelpers.method_exists?(:cname_for)
+      # introduced in Zeitwerk v2.6.10
+      def cname_for(basename, abspath)
+        super(Onload.basename(basename), abspath)
+      end
     end
   end
-end
 
-module Zeitwerk
-  class Loader
-    prepend Onload::ZeitwerkLoaderPatch
+  module ZeitwerkFileSystemPatch
+    def rb_extension?(path)
+      super || Onload.process?(path)
+    end
   end
 end
+
+Zeitwerk::Loader.prepend(Onload::ZeitwerkLoaderPatch)
+
+if defined?(Zeitwerk::Loader::FileSystem)
+  Zeitwerk::Loader::FileSystem.prepend(Onload::ZeitwerkFileSystemPatch)
+end

data/lib/onload/file.rb

@@ -8,14 +8,22 @@ module Onload
       @path = path
     end
 
-    def write
+    def write(ignore_file: nil)
       source = ::File.read(path)
 
       ::File.extname(path).scan(/\.\w+/).each do |ext|
         source = Onload.processors[ext].call(source)
       end
 
-      ::File.write(outfile, source)
+      ::File.write(outfile, source).tap do
+        if ignore_file
+          ignore_file.add(outfile)
+        elsif Onload.config.ignore_path
+          ignore_file = IgnoreFile.load(Onload.config.ignore_path)
+          ignore_file.add(outfile)
+          ignore_file.persist!
+        end
+      end
     end
 
     def outfile

data/lib/onload/ignore_file.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Onload
+  class MalformedIgnoreFileError < StandardError; end
+
+  class IgnoreFile
+    ONLOAD_SECTION_START = "##### ONLOAD BUILD ARTIFACTS (AUTO-GENERATED) #####"
+    ONLOAD_SECTION_STOP  = "##### END ONLOAD BUILD ARTIFACTS #####"
+
+    class << self
+      def load(manifest_path)
+        manifest_path = ::File.expand_path(manifest_path)
+        lines = ::File.read(manifest_path).split(/\r?\n/)
+        start_idx = lines.index(ONLOAD_SECTION_START)
+        stop_idx = lines.index(ONLOAD_SECTION_STOP)
+
+        # Start and stop indices should either both be numbers or both be nil.
+        # Anything else, and something weird is going on.
+        if start_idx.class != stop_idx.class
+          raise MalformedIgnoreFileError, "the ignore file at #{manifest_path} appears to be malformed and onload doesn't know how to modify it"
+        end
+
+        ignored_paths = if start_idx && stop_idx
+          lines[start_idx..stop_idx].map(&:strip)
+        else
+          []
+        end
+
+        ignored_paths.reject! do |path|
+          path.empty? || path.start_with?("#")
+        end
+
+        new(manifest_path, Set.new(ignored_paths))
+      end
+    end
+
+    attr_reader :manifest_path, :dirty
+
+    alias dirty? dirty
+
+    def initialize(manifest_path, ignored_paths)
+      @manifest_path = manifest_path
+      @ignored_paths = ignored_paths
+      @dirty = false
+    end
+
+    def includes?(path)
+      @ignored_paths.include?(path)
+    end
+
+    alias include? includes?
+
+    def add(path)
+      ignored_path = ::File.expand_path(path)
+      ignored_path_segments = ignored_path.split(::File::SEPARATOR)
+
+      if ignored_path_segments[0...manifest_dirname_segments.size] != manifest_dirname_segments
+        raise "file to ignore #{path} is not relative to the specified ignore file at #{manifest_path}"
+      end
+
+      relative_ignored_path = ignored_path_segments[manifest_dirname_segments.size..-1].join(::File::SEPARATOR)
+      @ignored_paths << relative_ignored_path
+
+      @dirty = true
+
+      nil
+    end
+
+    def persist!
+      return unless dirty?
+
+      lines = ::File.read(manifest_path).split(/\r?\n/)
+      start_idx = lines.index(ONLOAD_SECTION_START)
+      stop_idx = lines.index(ONLOAD_SECTION_STOP)
+
+      if start_idx && stop_idx
+        lines[start_idx..stop_idx] = [
+          ONLOAD_SECTION_START,
+          *@ignored_paths,
+          ONLOAD_SECTION_STOP
+        ]
+      else
+        lines += [
+          "",
+          ONLOAD_SECTION_START,
+          *@ignored_paths,
+          ONLOAD_SECTION_STOP,
+          ""
+        ]
+      end
+
+      contents = lines.join("\n")
+      contents << "\n" unless contents.end_with?("\n")
+
+      ::File.write(manifest_path, contents)
+
+      @dirty = false
+    end
+
+    private
+
+    def manifest_dirname
+      @manifest_dirname ||= ::File.dirname(manifest_path)
+    end
+
+    def manifest_dirname_segments
+      @manifest_diranme_segments ||= manifest_dirname.split(::File::SEPARATOR)
+    end
+  end
+end

data/lib/onload/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Onload
-  VERSION = "1.0.5"
+  VERSION = "1.1.1"
 end

data/lib/onload.rb

@@ -3,12 +3,17 @@
 module Onload
   UNLOADABLE_EXTENSIONS = %w(.bundle .so .dll).freeze
 
-  autoload :File, "onload/file"
+  autoload :Config,     "onload/config"
+  autoload :File,       "onload/file"
+  autoload :IgnoreFile, "onload/ignore_file"
 
   class << self
     attr_accessor :enabled
     alias enabled? enabled
 
+    attr_reader :installed
+    alias installed? installed
+
     def register(extension, processor_klass)
       processors[extension] = processor_klass
     end
@@ -41,6 +46,8 @@ module Onload
       else
         require "onload/ext/bootsnap/autoload"
       end
+
+      @installed = true
     end
 
     def process?(path)
@@ -105,6 +112,27 @@ module Onload
       @glob ||= "*{#{each_extension.to_a.join(",")}}"
     end
 
+    def config
+      @config ||= Config.new
+    end
+
+    def with_config(override_hash)
+      new_config = config.dup.tap do |new_config|
+        override_hash.each_pair do |k, v|
+          new_config.send("#{k}=", v)
+        end
+      end
+
+      old_config = config
+      @config = new_config
+
+      yield
+
+      nil
+    ensure
+      @config = old_config
+    end
+
     private
 
     def path_cache
@@ -113,6 +141,7 @@ module Onload
   end
 
   self.enabled = true
+  @installed = false
 end
 
 if Kernel.const_defined?(:Rails)

data/spec/fixtures/hello.rb

@@ -0,0 +1,5 @@
+class Hello
+  def hello
+    "hello".upcase
+  end
+end

data/spec/rails/controllers/home_controller_spec.rb

@@ -13,6 +13,15 @@ describe HomeController, type: :request do
       )
     end
 
+    it "adds an entry to the specified ignore file" do
+      Onload.with_config(ignore_path: @ignore_path) do
+        get "/"
+
+        ignore_file = Onload::IgnoreFile.load(@ignore_path)
+        expect(ignore_file).to include("fixtures/hello.rb")
+      end
+    end
+
     it "allows hot reloading" do
       get "/"