hot_reloader 0.5.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2bf9cabe1a8e3383c6fcdaaa3530f249a5df5742918831bc414aa30ae9b251f
-  data.tar.gz: c4e1a3e0ddbc2332b16be27c4758d015e602b3cb9c4ddad70f257144c7004440
+  metadata.gz: 282ee5c0dc94f37d38e97f5ca54134c341c9566729fcdb82cb9be2352a6c62f1
+  data.tar.gz: 583954d5950e4c954b6dc668c5f7726b92b986026bfc180efd1aee6bff7377b9
 SHA512:
-  metadata.gz: c8d4d1580458d66f0a03fdeb252f57074776d6dd07dd6711f805e537ff87267f8c3b24cc289e44d62657a8308e41e56e6233f0e5e7600516684490412dd0432a
-  data.tar.gz: d2708191113c9441b7a8a769463ce5c6bd1967323703440d654de2e84e54625e289b2ffc920d52506b9045d16bdb7ca6171fe8f3f99aa79c9b614309b5f58975
+  metadata.gz: e69cf88b8edef12b7a22c39dd4a7163818097c4f9244047a637c5b771b0ef339783f5c579905fe5c4a61733a2cf6d7c619eaa7178b7952055c90bab7a4e35b5b
+  data.tar.gz: aa6f7ba74d2965fbecd221261581dc7d0fe56f213cadc31a3118c9e8b999bb963e184b1a6bcf535bfb34f47bbeef2d7b70cf096ee43ac891e18816f3ffd35d67

data/README.md

@@ -20,22 +20,28 @@ Add to your Gemfile
 
 Following is a example for use hot_reloader with [Roda](https://github.com/jeremyevans/roda):
 
-`config.ru` which used to start rack based web server with `command rackup -o 0.0.0.0 -p 9393`
+### Add loader initialize code into `config/environment.rb`
+
+For simple use case, you just need pass paths to `HotReloader.eager_load` or `HotReloader.will_listen`.
 
 ```rb
-# config.ru
+# config/environment.rb
 
-require_relative './config/environment'
+require 'bundler'
+Bundler.require(:default, ENV.fetch('RACK_ENV', "development"))
+require_relative 'application'
 
-if ENV['RACK_ENV'] == 'production'
-  run App.freeze.app
+paths = ["#{__dir__}/../app", "#{__dir__}/../app/models"]
+
+if ENV['RACK_ENV'] == 'development'
+  HotReloader.will_listen(*paths)
 else
-  run ->(env) { App.call(env) }
+  HotReloader.eager_load(*paths)
 end
 ```
 
-Add loader initialize code into `config/environment.rb`
-
+For more advanced case(e.g. you need setup zeitwerk loader instance yourself), you
+can pass this instance to HotReloader methods too.
 
 ```rb
 # config/environment.rb
@@ -47,41 +53,88 @@ require_relative 'application'
 loader = Zeitwerk::Loader.new
 loader.push_dir("#{__dir__}/../app")
 loader.push_dir("#{__dir__}/../app/models")
-loader.inflector.inflect "ar" => "AR"
 
-if ENV['RACK_ENV'] == 'production'
-  HotReloader.eager_load(loader)
-else
+if ENV['RACK_ENV'] == 'development'
   HotReloader.will_listen(loader)
+else
+  HotReloader.eager_load(loader)
 end
 ```
 
-Or use more simple form (if you don't need setup Zeitwerk loader youself)
+When you change root directories files(app/*.rb or app/models/*.rb for above case), 
+all monitored files will be reload.
 
+it is possible to trigger reload from any `.rb` files, even this file not follow constant 
+lookup name convention, and this file folder not add to root directories use `push_dir` method.
+
+Following is a example.
 
 ```rb
-# config/environment.rb
+# app/app.rb
 
-require 'bundler'
-Bundler.require(:default, ENV.fetch('RACK_ENV', "development"))
+class App < Roda
+  plugin :hash_routes
+  
+  Dir["routes/**/*.rb"].each do |route_file|
+    load route_file
+  end
+end
+```
 
-paths = ["#{__dir__}/../app", "#{__dir__}/../app/models"]
+```rb
+# routes/blog.rb
 
-if ENV['RACK_ENV'] == 'production'
-  HotReloader.eager_load(*paths)
+class App
+  hash_routes.on "blog" do |r|
+    "blog"
+  end
+end
+```
+
+`routes/blog.rb` is not follow constant lookup name convention, so, `routes/` folder can't be
+add to root directories use push_dir method, but you can always trigger with `loader.reload`
+if `routes/blog.rb` was changed, then when `app/app.rb` reloaded, it will load the
+newest code in `routes/blog.rb` from the Dir each loop.
+
+For achieve this, you only need pass listened folders to will_listen method as secondary arg.
+
+```rb
+loader = Zeitwerk::Loader.new
+loader.push_dir("#{__dir__}/../app")
+
+listened_folders = ["#{__dir__}/../routes"]
+
+if ENV['RACK_ENV'] == 'development'
+  HotReloader.will_listen(loader, listened_folders)
 else
-  HotReloader.will_listen(*paths)
+  HotReloader.eager_load(loader)
 end
+```
 
-require_relative 'application'
+### Add other app files
+
+`config.ru` which used to start rack based web server with `command rackup -o 0.0.0.0 -p 9393`
+
+```rb
+# config.ru
+
+require_relative './config/environment'
+
+if ENV['RACK_ENV'] == 'development'
+  run ->(env) { App.call(env) }
+else
+  run App.freeze.app
+end
 ```
 
-Write whatever application initialize code which need add into application.rb
+Write whatever application needed initialize code into config/application.rb
 
 ```rb
 # config/application.rb
 
-DB = Sequel.connect(ENV.fetch("DATABASE_URL"), timeout: 10000)
+DB = Sequel.connect(ENV.fetch("#{ENV.fetch('RACK_ENV', "development").upcase}_DATABASE_URL"), timeout: 10000)
+Sequel::Model.plugin :timestamps
+Sequel.extension :symbol_aref
 ```
 
 Add roda code into app/app.rb
@@ -115,7 +168,9 @@ Directory structure is like this:
 └── Gemfile.lock
 ```
 
-Change code in app.rb, **all constant get removed from memory, and app.rb evaluated again**!
+After change code in app.rb, **all constant get removed from memory, and app.rb evaluated again**!
+
+For a more rich WIP sample project, please check my another project [marketbet_crawler](https://github.com/zw963/marketbet_crawler).
 
 ## Support
 
@@ -124,8 +179,9 @@ Change code in app.rb, **all constant get removed from memory, and app.rb evalua
 
 ## Dependency
 
-zeitwerk https://github.com/fxn/zeitwerk
-listen https://github.com/guard/listen
+[zeitwerk](https://github.com/fxn/zeitwerk) https://github.com/fxn/zeitwerk
+
+[listen](https://github.com/guard/listen) https://github.com/guard/listen
 
 ## Contributing
 

data/lib/hot_reloader/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class HotReloader
-  VERSION = '0.5.0'
+  VERSION = '0.8.1'
 end

data/lib/hot_reloader.rb

@@ -10,31 +10,46 @@ class HotReloader
     #
     # @param [*String, Array<String>] folders Folders which should be monitor, can be multi-args or array.
     #   or only one Zeitwerk::Loader object can be provided.
-    # @param [#call] logger logger or any object should response call.
-    # @param [Array<String>] ignore Glob patterns or Pathname object which should be excluded.
+    # @param [#call] logger logger object, e.g. Logger.new($stdout).
+    # @param [Array<String>, Array<Pathname>] ignore File names, Glob patterns or Pathname object which should be excluded for zeitwerk.
+    # @param [Integer] wait_for_delay Set the delay (in seconds) before call loader.reload when changes exist.
+    # @param [Array<Regexp>] listen_ignore The regexp pattern which don't want listen on.
+    # @yield [] ruby code will be run after Zeitwerk loader get reloaded.
     # @return nil
-    def will_listen(*folders, logger: method(:puts), ignore: [])
+    def will_listen(*folders, logger: Logger.new(IO::NULL), ignore: [], wait_for_delay: nil, listen_ignore: [])
       folders = folders.flatten
 
       if folders.first.is_a? Zeitwerk::Loader
-        loader = folders.first
+        loader, *listened_folders = folders
         folders = loader.root_dirs.keys
+        # `folders' will add to zeitwerk root directories and listened.
+        # `reloadable_folder' listened only, it can be reload dynamically.
+        # but not constant lookup use name convention.
       else
         loader = Zeitwerk::Loader.new
 
-        raise 'you must set the root folders from which you want to load watched files.' if folders&.empty?
+        raise 'you must set the root directories from which you want to load watched files.' if folders&.empty?
         raise 'ignore: only accept an array of glob patterns string or Pathname objects.' unless ignore.is_a? Array
 
         folders.each {|folder| loader.push_dir(folder) }
+        listened_folders = []
       end
 
       loader.enable_reloading if loader.respond_to? :enable_reloading
       loader.logger = logger
-
       loader.ignore(ignore) unless ignore.empty?
-
       loader.setup
-      Listen.to(*folders, wait_for_delay: 1) { loader.reload }.start
+
+      Listen.logger = logger
+
+      listen_options = {ignore: [/\A\.?#/]}
+      listen_options.merge!({wait_for_delay: wait_for_delay}) if wait_for_delay
+      listen_options[:ignore].concat listen_ignore if listen_ignore
+
+      Listen.to(*(folders + listened_folders), listen_options) do
+        loader.reload
+        yield if block_given?
+      end.start
     end
 
     # Enable autoload ruby file based on default Zeitwerk rule.
@@ -42,9 +57,10 @@ class HotReloader
     #
     # @param [*String, Array<String>] folders folders which should be autoload, can be multi-args or array.
     #   or only one Zeitwerk::Loader object can be provided.
-    # @param [#call] logger logger or any object should response call.
+    # @param [#call] logger logger object, e.g. Logger.new($stdout)
+    # @param [Array<String>, Array<Pathname>] ignore File names, Glob patterns or Pathname object which should be excluded for zeitwerk.
     # @return nil
-    def eager_load(*folders, logger: method(:puts))
+    def eager_load(*folders, logger: Logger.new(IO::NULL), ignore: [])
       folders = folders.flatten
 
       if folders.first.is_a? Zeitwerk::Loader
@@ -52,12 +68,15 @@ class HotReloader
         folders = loader.root_dirs.keys
       else
         loader = Zeitwerk::Loader.new
-        raise 'you must set the root folders from which you want to load watched files.' if folders&.empty?
+
+        raise 'you must set the root directories from which you want to load watched files.' if folders&.empty?
+        raise 'ignore: only accept an array of glob patterns string or Pathname objects.' unless ignore.is_a? Array
 
         folders.each {|folder| loader.push_dir(folder) }
       end
 
       loader.logger = logger
+      loader.ignore(ignore) unless ignore.empty?
 
       loader.setup
       loader.eager_load

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hot_reloader
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Billy.Zheng(zw963)
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-08 00:00:00.000000000 Z
+date: 2021-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk