hot_reloader 0.3.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f7a23dab8a6321213fc337a02d143cb8ed0eb8414a08178d5ab485975935822
-  data.tar.gz: 94240e3303b304cb0ab08ef8be9c587a0e77944a1b52203d3f2970a553a454af
+  metadata.gz: 9421c166738e6fafb613ca2dac2bc28bd99b53a6229d4c0720db14f2e0c0ae25
+  data.tar.gz: a5677eaf835907fc683a591bd5e746008aa9fe42f296fa0585372482f2df92fd
 SHA512:
-  metadata.gz: 88e7cc2a2ab94b09f50bed1c095c6d446472f09f47f3de402c2b7c515a660251ac5551a4ca14dd7a1713e2096fbcc32f12b23fd306d29af7760c44d3c36d51f0
-  data.tar.gz: 7c872ea05e0146a656758cd6ee2d4b0a08905c342e34029f3f42a0f32f7838b99377874b117a5c1ac330325cef949f09eca767a29c3852e00a853167741f54ed
+  metadata.gz: 14c1d5918b46577369366f01912de5b1b61907195eedf2c182b87022c1d33796a65ec43a90efe21e72d3211b341b29a247c24383f2da499ed5a7a98116dc136b
+  data.tar.gz: f6668adecc4df04439245a41d5b7327ec03b0f3e14b8bee313ec529b9275ebc5b57a4667d93c85e1e21118a54b33169d77765bb83eca73e8c24491eeb2091e0a

data/README.md

@@ -1,4 +1,4 @@
-# HotReloader [![Build Status](https://travis-ci.org/zw963/hot_reloader.svg?branch=master)](https://travis-ci.org/zw963/hot_reloader) [![Gem Version](https://badge.fury.io/rb/hot_reloader.svg)](http://badge.fury.io/rb/hot_reloader)
+# HotReloader [![Build Status](https://travis-ci.com/zw963/hot_reloader.svg?branch=master)](https://travis-ci.com/zw963/hot_reloader) [![Gem Version](https://badge.fury.io/rb/hot_reloader.svg)](http://badge.fury.io/rb/hot_reloader)
 
 A dead simple ruby code hot reloader wrap around [zeitwerk](https://github.com/fxn/zeitwerk) and [listen](https://github.com/guard/listen).
 
@@ -20,31 +20,136 @@ 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`
+
 ```rb
 # config.ru
 
-require 'roda'
-require 'hot_reloader'
+require_relative './config/environment'
 
-if ENV['RACK_ENV'] == 'production'
-  HotReloader.eager_load(__dir__, 'another/root/path')
-  run App
-else
-  HotReloader.will_listen([__dir__, 'another/root/path'])
+if ENV['RACK_ENV'] == 'development'
   run ->(env) { App.call(env) }
+else
+  run App.freeze.app
+end
+```
+
+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/environment.rb
+
+require 'bundler'
+Bundler.require(:default, ENV.fetch('RACK_ENV', "development"))
+require_relative 'application'
+
+paths = ["#{__dir__}/../app", "#{__dir__}/../app/models"]
+
+if ENV['RACK_ENV'] == 'development'
+  HotReloader.will_listen(*paths)
+else
+  HotReloader.eager_load(*paths)
 end
 ```
 
+For more advanced case(e.g. you need setup zeitwerk loader instance yourself), you
+can pass this instance to HotReloader methods too.
+
 ```rb
-# app.rb
+# config/environment.rb
+
+require 'bundler'
+Bundler.require(:default, ENV.fetch('RACK_ENV', "development"))
+require_relative 'application'
+
+loader = Zeitwerk::Loader.new
+loader.push_dir("#{__dir__}/../app")
+loader.push_dir("#{__dir__}/../app/models")
+
+if ENV['RACK_ENV'] == 'development'
+  HotReloader.will_listen(loader)
+else
+  HotReloader.eager_load(loader)
+end
+```
+
+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
+# app/app.rb
 
 class App < Roda
-  articles = []
+  plugin :hash_routes
+  
+  Dir["routes/**/*.rb"].each do |route_file|
+    load route_file
+  end
+end
+```
+
+```rb
+# routes/blog.rb
+
+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.
+
+```
+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.eager_load(loader)
+end
+```
+
+Write whatever application initialize code which need add into application.rb
+
+```rb
+# config/application.rb
+
+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
+
+```rb
+# app/app.rb
+
+class App < Roda
+  articles = ['programming ruby', 'programming rust']
   route do |r|
     r.post "articles" do
-    articles << r.params["content"]
-    "Count: #{articles.count}"
+      articles << r.params["content"]
+      "Count: #{articles.count}"
+    end
+	
+	r.get "articles" do
+      articles.join(', ')
     end
   end
 end
@@ -53,13 +158,17 @@ end
 Directory structure is like this:
 
 ```
-├── app.rb
+├── app/app.rb
+├── config/environment.rb
+├── config/application.rb
 ├── config.ru
 ├── Gemfile
 └── 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
 

data/lib/hot_reloader.rb

@@ -1,57 +1,74 @@
 # frozen_string_literal: true
 
-require 'singleton'
 require 'zeitwerk'
 require 'listen'
 
 class HotReloader
-  include Singleton
-
-  # @private
-  def initialize
-    @loader = Zeitwerk::Loader.new
-  end
-
   class << self
-    # Listen folders for file change, and reload changed rb file,
+    # Listen on folders for file change, and reload changed rb file if necessary.
     # Should be used for development mode only.
     #
     # @param [*String, Array<String>] folders Folders which should be monitor, can be multi-args or array.
-    # @param [#call] logger logger or any object should response call.
+    #   or only one Zeitwerk::Loader object can be provided.
+    # @param [#call] logger logger or any object should response call, e.g. method(:puts), $stdout, $stderr.
     # @param [Array<String>] ignore Glob patterns or Pathname object which should be excluded.
     # @return nil
-    def will_listen(*folders, logger: method(:puts), ignore: [])
+    def will_listen(*folders, logger: Logger.new(IO::NULL), ignore: [])
       folders = folders.flatten
-      setup_loader(folders, logger: logger, ignore: ignore)
-      Listen.to(*folders, wait_for_delay: 1) { loader.reload }.start
+
+      if folders.first.is_a? Zeitwerk::Loader
+        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 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.logger = logger
+
+      Listen.to(*(folders + listened_folders), wait_for_delay: 1, ignore: /\.#.*/) { loader.reload }.start
     end
 
     # Enable autoload ruby file based on default Zeitwerk rule.
     # More rule see https://github.com/fxn/zeitwerk
     #
     # @param [*String, Array<String>] folders folders which should be autoload, can be multi-args or array.
-    # @param [#call] logger logger or any object should response call.
+    #   or only one Zeitwerk::Loader object can be provided.
+    # @param [#call] logger logger or any object should response call, e.g. method(:puts), $stdout, $stderr.
     # @return nil
-    def eager_load(*folders, logger: method(:puts))
+    def eager_load(*folders, logger: Logger.new(IO::NULL), ignore: [])
       folders = folders.flatten
-      setup_loader(folders, logger: logger, ignore: [])
-      loader.eager_load
-    end
 
-    private
+      if folders.first.is_a? Zeitwerk::Loader
+        loader = folders.first
+        folders = loader.root_dirs.keys
+      else
+        loader = Zeitwerk::Loader.new
 
-    def loader
-      instance.instance_variable_get(:@loader)
-    end
+        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
 
-    def setup_loader(folders, logger:, ignore:)
-      raise 'ignore: only accept an array of glob patterns string or Pathname objects.' unless ignore.is_a? Array
-      raise 'you must set the root folders from which you want to load watched files.' if folders&.empty?
+        folders.each {|folder| loader.push_dir(folder) }
+      end
 
-      folders.each {|folder| loader.push_dir(folder) }
       loader.logger = logger
       loader.ignore(ignore) unless ignore.empty?
+
       loader.setup
+      loader.eager_load
     end
   end
 end

data/lib/hot_reloader/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hot_reloader
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Billy.Zheng(zw963)
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-03-31 00:00:00.000000000 Z
+date: 2021-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '2.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: listen
   requirement: !ruby/object:Gem::Requirement
@@ -53,7 +53,7 @@ homepage: http://github.com/zw963/hot_reloader
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -68,8 +68,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: A dead simple ruby code hot reloader wrap around zeitwerk and listen.
 test_files: []