Implement module reloading on file change

Author: noteflakes

.rubocop.yml

@@ -35,8 +35,8 @@ AllCops:
 # Style/MultilineBlockChain:
 #   Enabled: false
 
-# Lint/RescueException:
-#   Enabled: false
+Lint/RescueException:
+  Enabled: false
 
 # Lint/InheritException:
 #   Enabled: false

TODO.md

@@ -1,97 +0,0 @@
-## Server tool
-
-```bash
-$ bundle exec syntropy --dev ./site
-$ bundle exec syntropy --workers 4 ./site
-```
-
-And also a config file:
-
-```bash
-$ bundle exec syntropy site.rb
-```
-
-And the config file:
-
-```ruby
-# site.rb
-Syntropy.config do
-  root './site'
-  workers 4
-  log { |req| }
-end
-```
-
-## Lightweight model API on top of Extralite
-
-- DB connection pool
-- Lightweight means 90% features with 10% effort:
-
-```ruby
-Posts = Syntropy::Relation.new('posts')
-
-posts = Posts.order_by(:stamp, :desc).all(db)
-
-post = Posts.where(id: 13).first(db)
-
-id = Posts.insert(db, title: 'foo', body: 'bar')
-
-Posts.where(id: id).update(db, body: 'baz')
-
-Posts.where(id: id).delete(db)
-```
-
-The whole `db` argument thing is very limiting. For easier usage we integrate
-the db connection pool as dependency injection the model:
-
-```ruby
-db_pool = E2::ConnectionPool.new(fn)
-Posts = Syntropy::Dataset.new(db_pool, 'posts')
-
-Posts[id: 1] #=> { id: 1, title: 'foo', body: 'bar' }
-Posts.find(id: 1) #=>
-
-Posts.to_a #=> [...]
-Posts.order_by(:stamp, :desc).to_a #=> [...]
-
-id = Posts.insert(title: 'foo', body: 'bar')
-
-post = Posts.where(id: id)
-post.values #=> { id: 1, title: 'foo', body: 'bar' }
-post.update(body: 'baz') #=> 1
-post.delete
-```
-
-So basically it's a bit similar to Sequel datasets, but there's no "object instance as single row". The instance is the entire set of rows in the table, or a subset thereof:
-
-```ruby
-Posts.where(...).order_by(...).select(...).from(rowset)
-```
-
-How about CTEs?
-
-```ruby
-Users = Syntrop::Dataset.new(db_pool, 'users')
-
-GroupIdRowset = Syntropy::Dataset {
-  with(
-    foo: Users,
-    bar: -> {
-      select user_id, group
-      from foo
-    },
-    baz: -> {
-      select id
-      from bar
-      where user_id == bar.select(:user_id)
-    }
-  )
-
-  select_all
-  from baz
-  where id == :group_id
-}
-
-users = GroupIdRowset.bind(group_id: 5).to_a
-
-```

bin/syntropy

@@ -56,6 +56,10 @@ if !File.directory?(opts[:location])
   exit
 end
 
+
+
 opts[:machine] = UM.new
-app = Syntropy::App.new(opts[:machine], opts[:location], '/', watch_files: 0.05)
-TP2.run(opts) { app.(it) }
+opts[:logger] = opts[:logger] && TP2::Logger.new(opts[:machine], **opts)
+
+app = Syntropy::App.new(opts[:machine], opts[:location], '/', opts)
+TP2.run(opts) { app.call(it) }

lib/syntropy/app.rb

@@ -12,22 +12,20 @@ module Syntropy
   class App
     attr_reader :route_cache
 
-    def initialize(machine, src_path, mount_path, env = {})
+    def initialize(machine, src_path, mount_path, opts = {})
       @machine = machine
-      @src_path = src_path
+      @src_path = File.expand_path(src_path)
       @mount_path = mount_path
       @route_cache = {}
-      @env = env
+      @opts = opts
 
       @relative_path_re = calculate_relative_path_re(mount_path)
-      if (wf = env[:watch_files])
-        period = wf.is_a?(Numeric) ? wf : 0.1
-        machine.spin do
-          Syntropy.file_watch(@machine, src_path, period: period) { invalidate_cache(it) }
-        rescue Exception => e
-          p e
-          p e.backtrace
-        end
+      @machine.spin do
+        # we do startup stuff asynchronously, in order to first let TP2 do its
+        # setup tasks
+        @machine.sleep 0.25
+        @opts[:logger]&.call("Serving from #{File.expand_path(@src_path)}")
+        start_file_watcher if opts[:watch_files]
       end
     end
 
@@ -42,15 +40,6 @@ def find_route(path, cache: true)
       entry
     end
 
-    def invalidate_cache(fn)
-      invalidated_keys = []
-      @route_cache.each do |k, v|
-        invalidated_keys << k if v[:fn] == fn
-      end
-
-      invalidated_keys.each { @route_cache.delete(it) }
-    end
-
     def call(req)
       entry = find_route(req.path)
       render_entry(req, entry)
@@ -62,6 +51,32 @@ def call(req)
 
     private
 
+    def start_file_watcher
+      @opts[:logger]&.call('Watching for module file changes...', nil)
+      wf = @opts[:watch_files]
+      period = wf.is_a?(Numeric) ? wf : 0.1
+      @machine.spin do
+        Syntropy.file_watch(@machine, @src_path, period: period) do
+          @opts[:logger]&.call("Detected changed file: #{it}")
+          invalidate_cache(it)
+        rescue Exception => e
+          p e
+          p e.backtrace
+          exit!
+        end
+      end
+    end
+
+    def invalidate_cache(fn)
+      invalidated_keys = []
+      @route_cache.each do |k, v|
+        @opts[:logger]&.call("Invalidate cache for #{k}", nil)
+        invalidated_keys << k if v[:fn] == fn
+      end
+
+      invalidated_keys.each { @route_cache.delete(it) }
+    end
+
     def calculate_relative_path_re(mount_path)
       mount_path = '' if mount_path == '/'
       /^#{mount_path}(?:\/(.*))?$/
@@ -95,7 +110,7 @@ def calculate_route(path)
     end
 
     def file_entry(fn)
-      { fn: fn, kind: FILE_KINDS[File.extname(fn)] || :static }
+      { fn: File.expand_path(fn), kind: FILE_KINDS[File.extname(fn)] || :static }
     end
 
     def find_index_entry(dir)
@@ -138,19 +153,23 @@ def render_entry(req, entry)
       when :not_found
         req.respond('Not found', ':status' => Qeweney::Status::NOT_FOUND)
       when :static
-        entry[:mime_type] ||= Qeweney::MimeTypes[File.extname(entry[:fn])]
-        req.respond(IO.read(entry[:fn]), 'Content-Type' => entry[:mime_type])
+        respond_static(req, entry)
       when :markdown
         body = render_markdown(IO.read(entry[:fn]))
         req.respond(body, 'Content-Type' => 'text/html')
       when :module
-        call_module(entry, req)
+        call_module(req, entry)
       else
-        raise "Invalid entry kind"
+        raise 'Invalid entry kind'
       end
     end
 
-    def call_module(entry, req)
+    def respond_static(req, entry)
+      entry[:mime_type] ||= Qeweney::MimeTypes[File.extname(entry[:fn])]
+      req.respond(IO.read(entry[:fn]), 'Content-Type' => entry[:mime_type])
+    end
+
+    def call_module(req, entry)
       entry[:code] ||= load_module(entry)
       if entry[:code] == :invalid
         req.respond(nil, ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
@@ -165,17 +184,13 @@ def call_module(entry, req)
     end
 
     def load_module(entry)
-      loader = Syntropy::ModuleLoader.new(@src_path, @env)
+      loader = Syntropy::ModuleLoader.new(@src_path, @opts)
       ref = entry[:fn].gsub(%r{^#{@src_path}\/}, '').gsub(/\.rb$/, '')
       o = loader.load(ref)
       # klass = Class.new
       # o = klass.instance_eval(body, entry[:fn], 1)
 
-      if o.is_a?(Papercraft::HTML)
-        return wrap_template(o)
-      else
-        return o
-      end
+      o.is_a?(Papercraft::HTML) ? wrap_template(o) : o
     end
 
     def wrap_template(templ)

syntropy.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'json',          '2.12.2'
   s.add_dependency 'papercraft',    '1.4'
   s.add_dependency 'qeweney',       '0.21'
-  s.add_dependency 'tp2',           '0.12.2'
+  s.add_dependency 'tp2',           '0.12.3.1'
   s.add_dependency 'uringmachine',  '0.15'
 
   s.add_dependency 'listen',        '3.9.0'