rack-unreloader 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f60b8ff5b4384a7f55f92c4e851e2589622112228849b63ed7cf520b2e4b4112
-  data.tar.gz: e01e616600037edc3eb954dd9cf7fd6c8667fa43b15590ec4bb5041547c5f4af
+  metadata.gz: 01a3ddc58ad8308cd61dd10991e7478f546bd7d1bc2fc4bb88203b4a37d7b335
+  data.tar.gz: ceff468f0b2755347859e3d2a408087379a056975e00c73fe35adc5854c3cbc0
 SHA512:
-  metadata.gz: 5da4eebc546fcc8194667ca1c1176574f6299a2bef8b062f24edf09146fc151f234b8119af9c19120f5245a5b921cb6841bba29c4bfc20abdc5d229ac040305a
-  data.tar.gz: f7fcb791cb9a0d8f585444ba7bddc4f2ffd80759c4544c8a450c8ebeb38b8620bf24cd05c6a368921c395c9de2ddb1a60f6a31a26a30d76df2d458de35355904
+  metadata.gz: 71c0dc1e1ebfcad459d8bf6d1533200ad071f857fe2b53fb7f26af1e079169eca3835b2b1eee4a39d572244bf3208bd51718120f7e89f4dcd5b646cbed6195ca
+  data.tar.gz: d9e9ab98a9b36a44d0d819f0142a1c9c49a21598a390da18c7cee48199cd365a0acac7c4fd95955e49b3f18a7ef8e0fe75bfa138312e3b2d16f57ebc7574731f

data/CHANGELOG

@@ -1,3 +1,9 @@
+= 2.1.0 (2023-01-18)
+
+* Add reload? and autoload? methods for determining what mode the unreloader is operating in (jeremyevans)
+
+* Support :autoload option and autoload method for autoloading files and directories (jeremyevans)
+
 = 2.0.0 (2022-06-23)
 
 * Fix TypeError being raised when requiring a file results in an error (jeremyevans)

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2021 Jeremy Evans
+Copyright (c) 2014-2023 Jeremy Evans
 Copyright (c) 2011 Padrino
 
 Permission is hereby granted, free of charge, to any person obtaining

data/README.rdoc

@@ -195,7 +195,7 @@ class.
 
 == Requiring
 
-Rack::Unreloader#require is a little different than require in that it takes
+Rack::Unreloader#require is a little different than Kernel#require in that it takes
 a file glob, not a normal require path.  For that reason, you must specify
 the extension when requiring the file, and it will only look in the current
 directory by default:
@@ -253,6 +253,45 @@ decide that instead of specifying the constants, ObjectSpace should be used to
 automatically determine the constants loaded. You can specify this by having the
 block return the :ObjectSpace symbol.
 
+=== Autoload
+
+To further speed things up in development mode, or when only running a subset of
+tests, it can be helpful to autoload files instead of require them, so that if
+the related constants are not accessed, you don't need to pay the cost of loading
+the related files.  To enable autoloading, pass the +:autoload+ option when
+creating the reloader:
+
+  Unreloader = Rack::Unreloader.new(autoload: true){App}
+
+Then, you can call +autoload+ instead of +require+:
+
+  Unreloader.autoload('models'){|f| File.basename(f).sub(/\.rb\z/, '').capitalize}
+
+This will monitor the models directory for files, setting up autoloads for each
+file.  After the file has been loaded, normal reloading will happen for the
+file. Note that for +autoload+, a block is required because the constant names
+are needed before loading the file to setup the autoload.
+
+If the <tt>reload: false</tt> option is given when creating the reloader,
+autoloads will still be setup by +autoload+, but no reloading will happen. This
+can be useful when testing subsets of an application.  When testing subsets of
+an application, you don't need reloading, but you can benefit from autoloading,
+so parts of the application you are not testing are not loaded.
+
+If you do not pass the +:autoload+ option when creating the reloader, then calls
+to +autoload+ will implicitly be transformed to calls to +require+.  This makes
+it possible to use the same +autoload+ call in all cases, and handle four
+separate scenarios:
+
+1. Autoload then reload: Fast development mode startup, loading the minimum
+   number of files, but reloading if those files are changed
+2. Autoload without reload: Useful for faster testing of a subset of an
+   application, so the untested subsets is not loaded.
+3. Require then reload: Slower development mode startup, but have entire
+   application loaded before accepting requests
+4. Require without reload: Normal production/testing mode with nothing autoloaded
+   or reloaded
+
 == Usage Outside Rack
 
 While +Rack::Unreloader+ is usually in the development of rack applications,

data/lib/rack/unreloader/autoload_reloader.rb

@@ -0,0 +1,89 @@
+require_relative 'reloader'
+
+module Rack
+  class Unreloader
+    class AutoloadReloader < Reloader
+      def initialize(opts={})
+        super
+
+        # Files that autoloads have been setup for, but have not yet been loaded.
+        # Hash with realpath keys and values that are arrays with the
+        # a block that will return constant name strings that will autoload the 
+        # file, the modified time the file, and the delete hook.
+        @autoload_files = {}
+
+        # Directories where new files will be setup for autoloading.
+        # Uses same format as @monitor_dirs.
+        @autoload_dirs = {}
+      end
+
+      def autoload_dependencies(paths, opts={}, &block)
+        delete_hook = opts[:delete_hook]
+
+        Unreloader.expand_paths(paths).each do |file|
+          if File.directory?(file)
+            @autoload_dirs[file] = [nil, [], block, delete_hook]
+            check_autoload_dir(file)
+          else
+            # Comparisons against $LOADED_FEATURES need realpaths
+            @autoload_files[File.realpath(file)] = [block, modified_at(file), delete_hook]
+            Unreloader.autoload_constants(yield(file), file, @logger)
+          end
+        end
+      end
+
+      def remove_autoload(file, strings)
+        strings = Array(strings)
+        log("Removing autoload for #{file}: #{strings.join(" ")}") unless strings.empty?
+        strings.each do |s|
+          obj, mod = Unreloader.split_autoload(s)
+          # Assume that if the autoload string was valid to create the
+          # autoload, it is still valid when removing the autoload.
+          obj.send(:remove_const, mod)
+        end
+      end
+
+      def check_autoload_dir(dir)
+        subdir_times, files, block, delete_hook = md = @autoload_dirs[dir]
+        return if subdir_times && subdir_times.all?{|subdir, time| File.directory?(subdir) && modified_at(subdir) == time}
+        md[0] = subdir_times(dir)
+
+        cur_files = Unreloader.ruby_files(dir)
+        return if files == cur_files
+
+        removed_files = files - cur_files
+        new_files = cur_files - files
+
+        # Removed files that were never required should have the constant removed
+        # so that accesses to the constant do not attempt to autoload a file that
+        # no longer exists.
+        removed_files.each do |file|
+          remove_autoload(file, block.call(file)) unless @monitor_files[file]
+        end
+
+        # New files not yet loaded should have autoloads added for them.
+        autoload_dependencies(new_files, :delete_hook=>delete_hook, &block) unless new_files.empty?
+
+        files.replace(cur_files)
+      end
+
+      def reload!
+        (@autoload_files.keys & $LOADED_FEATURES).each do |file|
+          # Files setup for autoloads were autoloaded, move metadata to locations
+          # used for required files.
+          log("Autoloaded file required, setting up reloading: #{file}")
+          block, *metadata = @autoload_files.delete(file)
+          @constants_defined[file] = block
+          @monitor_files[file] = metadata
+          @files[file] = {:features=>Set.new, :constants=>Array(block.call(file))}
+        end
+
+        @autoload_dirs.each_key do |dir|
+          check_autoload_dir(dir)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rack/unreloader/reloader.rb

@@ -5,9 +5,6 @@ module Rack
     class Reloader
       File = ::File
 
-      # Regexp for valid constant names, to prevent code execution.
-      VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
-
       # Setup the reloader.  Supports :logger and :subclasses options, see
       # Rack::Unloader.new for details.
       def initialize(opts={})

data/lib/rack/unreloader.rb

@@ -8,9 +8,12 @@ module Rack
     # Mutex used to synchronize reloads
     MUTEX = Monitor.new
 
-    # Reference to ::File as File would return Rack::File by default.
+    # Reference to ::File as File may return Rack::File by default.
     File = ::File
 
+    # Regexp for valid constant names, to prevent code execution.
+    VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
+
     # Given the list of paths, find all matching files, or matching ruby files
     # in subdirecories if given a directory, and return an array of expanded
     # paths.
@@ -41,11 +44,51 @@ module Rack
       files.sort
     end
 
+    # Autoload the file for the given objects.  objs should be a string, symbol,
+    # or array of them holding a Ruby constant name.  Access to the constant will
+    # load the related file.  A non-nil logger will have output logged to it.
+    def self.autoload_constants(objs, file, logger)
+      strings = Array(objs).map(&:to_s)
+      if strings.empty?
+        # Remove file from $LOADED_FEATURES if there are no constants to autoload.
+        # In general that is because the file is part of another class that will
+        # handle loading the file separately, and if that class is reloaded, we
+        # want to remove the loaded feature so the file can get loaded again.
+        $LOADED_FEATURES.delete(file)
+      else
+        logger.info("Setting up autoload for #{file}: #{strings.join(' ')}") if logger
+        strings.each do |s|
+          obj, mod = split_autoload(s)
+
+          if obj
+            obj.autoload(mod, file)
+          elsif logger
+            logger.info("Invalid constant name: #{s}")
+          end
+        end
+      end
+    end
+
+    # Split the given string into an array. The first is a module/class to add the
+    # autoload to, and the second is the name of the constant to be autoloaded.
+    def self.split_autoload(mod_string)
+      if m = VALID_CONSTANT_NAME_REGEXP.match(mod_string)
+        ns, sep, mod = m[1].rpartition('::')
+        if sep.empty?
+          [Object, mod]
+        else
+          [Object.module_eval("::#{ns}", __FILE__, __LINE__), mod]
+        end
+      end
+    end
+
     # The Rack::Unreloader::Reloader instead related to this instance, if one.
     attr_reader :reloader
 
     # Setup the reloader. Options:
     # 
+    # :autoload :: Whether to allow autoloading.  If not set to true, calls to
+    #              autoload will eagerly require the related files instead of autoloading.
     # :cooldown :: The number of seconds to wait between checks for changed files.
     #              Defaults to 1.  Set to nil/false to not check for changed files.
     # :handle_reload_errors :: Whether reload to handle reload errors by returning
@@ -59,12 +102,19 @@ module Rack
     #                match exactly, since modules don't have superclasses.
     def initialize(opts={}, &block)
       @app_block = block
+      @autoload = opts[:autoload]
+      @logger = opts[:logger]
       if opts.fetch(:reload, true)
         @cooldown = opts.fetch(:cooldown, 1)
         @handle_reload_errors = opts[:handle_reload_errors]
         @last = Time.at(0)
-        require_relative 'unreloader/reloader'
-        @reloader = Reloader.new(opts)
+        if @autoload
+          require_relative('unreloader/autoload_reloader')
+          @reloader = AutoloadReloader.new(opts)
+        else
+          require_relative('unreloader/reloader')
+          @reloader = Reloader.new(opts)
+        end
         reload!
       else
         @reloader = @cooldown = @handle_reload_errors = false
@@ -87,6 +137,18 @@ module Rack
       @app_block.call.call(env)
     end
 
+    # Whether the unreloader is setup for reloading. If false, no reloading
+    # is done after the initial require.
+    def reload?
+      !!@reloader
+    end
+
+    # Whether the unreloader is setup for autoloading. If false, autoloads
+    # are treated as requires.
+    def autoload?
+      !!@autoload
+    end
+
     # Add a file glob or array of file globs to monitor for changes.
     # Options:
     # :delete_hook :: When a file being monitored is deleted, call
@@ -99,6 +161,24 @@ module Rack
       end
     end
 
+    # Add a file glob or array of file global to autoload and monitor
+    # for changes. A block is required.  It will be called with the
+    # path to be autoloaded, and should return the symbol for the
+    # constant name to autoload. Accepts the same options as #require.
+    def autoload(paths, opts={}, &block)
+      raise ArgumentError, "block required" unless block
+
+      if @autoload
+        if @reloader
+          @reloader.autoload_dependencies(paths, opts, &block)
+        else
+          Unreloader.expand_directory_paths(paths).each{|f| Unreloader.autoload_constants(yield(f), f, @logger)}
+        end
+      else
+        require(paths, opts, &block)
+      end
+    end
+
     # Records that each path in +files+ depends on +dependency+.  If there
     # is a modification to +dependency+, all related files will be reloaded
     # after +dependency+ is reloaded.  Both +dependency+ and each entry in +files+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-unreloader
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Jeremy Evans
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-23 00:00:00.000000000 Z
+date: 2023-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -67,6 +67,7 @@ files:
 - MIT-LICENSE
 - README.rdoc
 - lib/rack/unreloader.rb
+- lib/rack/unreloader/autoload_reloader.rb
 - lib/rack/unreloader/reloader.rb
 homepage: http://github.com/jeremyevans/rack-unreloader
 licenses:
@@ -76,7 +77,7 @@ metadata:
   changelog_uri: https://github.com/jeremyevans/rack-unreloader/blob/master/CHANGELOG
   mailing_list_uri: https://github.com/jeremyevans/rack-unreloader/discussions
   source_code_uri: https://github.com/jeremyevans/rack-unreloader
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--quiet"
 - "--line-numbers"
@@ -98,8 +99,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key: 
+rubygems_version: 3.4.1
+signing_key:
 specification_version: 4
 summary: Reload application when files change, unloading constants first
 test_files: []