syntropy 0.5 → 0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f125135bc3ed83c1050467241f48caf366600fead1d75db79455038e42e311a
-  data.tar.gz: ee9bd2bbf906eea9c90481ecdf643126285f65f63fe66a3f2b4f3050893e7c28
+  metadata.gz: 553553edc3b0c81902bc3a77470bc6e9789fcd757066dcd5b4e790d38f7a28bf
+  data.tar.gz: fdb2cec5f581ba49d5156cce188f31a4811d29767c71833bfcfa37899ee0efc5
 SHA512:
-  metadata.gz: 0bdce31c490701521d73829c02e1193fcd0da399b1e6186066ad5d6ecfa067dc143941300bf670fa4b447d5d5c177e903fa273d9d6d5bbfa2319ec0c74fd2678
-  data.tar.gz: 7b5eddf105f8654f379bf1d7f52948b713ee342dbd97eb1896e28b618b442ccf33c716d27a7f67c21cfd2c65f610b5c9677cd5e4faa0e777b8f727552628865c
+  metadata.gz: 7340ecb01725dcc15a78a66fef5f87a113c2e9759a2305753241b0c1cf738f45b3fd6fea2dcf7bca55196cc3fc309db2ade3e7bb12292fc5aa3abe63362403f9
+  data.tar.gz: 48427e653e2c99022177e5475ef53b66c57143288f43e4997c40f1ba464728b310c5e0df343e7f03e3ed79f9fa8637e305b6a22296b19fb15068b7228cf0531f

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.6 2025-07-05
+
+- Add support for middleware and error handlers
+
 ## 0.5 2025-07-05
 
 - Refactor App class to use Router

data/TODO.md

@@ -1,44 +1,33 @@
-- Refactor routing code into a separate Router class.
-- The Router class is in charge of:
-  - caching routes
-  - loading modules
-  - unloading modules on file change
-  - calculating middleware for routes
-    - middleware is defined in `_hook.rb` modules
-      - interface: ->(req, next)
-    - a special case for handling errors is `_error.rb`
-      - interface: ->(req, err)
-  - dispatching routes
-    - error handling:
-      - on uncaught error, if an `_error.rb` file exists in the same directory
-        or up the file tree
-    - middleware:
-      - a closure is created from the composition of the different hooks
-        defined, from the route's directory and up the file
-    - error handlers and middleware closures are cached as part of the route's
-      entry
-    - on file change for any _hook.rb or _error.rb files, all route entries in
-      the corresponding subtree are invalidated
-
-
-- Middleware
+- Some standard middleware:
+
+  - request rewriter
+  - logger
+  - auth
+  - selector + terminator
 
   ```Ruby
-  # site/_hook.rb
-  export ->(req, &app) do
-    app.call(req)
-  rescue Syntropy::Error => e
-    render_error_page(req, e.http_status)
+  # For the chainable DSL shown below, we need to create a custom class:
+  class Syntropy::Middleware::Selector
+    def initialize(select_proc, terminator_proc = nil)
+      @select_proc = select_proc
+      @terminator_proc = terminator_proc
+    end
+
+    def to_proc
+      ->(req, proc) {
+        @select_proc.(req) ? @terminator_proc.(req) : proc(req)
+      }
+    end
+
+    def terminate(&proc)
+      @terminator_proc = proc
+    end
   end
 
-  # an alternative, at least for errors is a _error.rb file:
-  # site/_error.rb
-  # Just a normal callable:
-  #
-  export ->(req, err) do
-    render_error_page(req, err.http_status)
-  end
+  def Syntropy
+  ```
 
+  ```Ruby
   # a _site.rb file can be used to wrap a whole app
   # site/_site.rb
 

data/lib/syntropy/app.rb

@@ -65,21 +65,32 @@ module Syntropy
     private
 
     def render_entry(req, entry)
+      kind = entry[:kind]
+      return respond_not_found(req) if kind == :not_found
+
+      entry[:proc] ||= calculate_route_proc(entry)
+      entry[:proc].(req)
+    end
+
+    def calculate_route_proc(entry)
+      render_proc = route_render_proc(entry)
+      @router.calc_route_proc_with_hooks(entry, render_proc)
+    end
+
+    def route_render_proc(entry)
       case entry[:kind]
-      when :not_found
-        respond_not_found(req, entry)
       when :static
-        respond_static(req, entry)
+        ->(req) { respond_static(req, entry) }
       when :markdown
-        respond_markdown(req, entry)
+        ->(req) { respond_markdown(req, entry) }
       when :module
-        respond_module(req, entry)
+        load_module(entry)
       else
         raise 'Invalid entry kind'
       end
     end
 
-    def respond_not_found(req, _entry)
+    def respond_not_found(req)
       headers = { ':status' => Qeweney::Status::NOT_FOUND }
       case req.method
       when 'head'

data/lib/syntropy/router.rb

@@ -2,8 +2,6 @@
 
 module Syntropy
   class Router
-    attr_reader :cache
-
     def initialize(opts, module_loader = nil)
       raise 'Invalid location given' if !File.directory?(opts[:location])
 
@@ -32,6 +30,10 @@ module Syntropy
       @machine.spin { file_watcher_loop }
     end
 
+    def calc_route_proc_with_hooks(entry, proc)
+      compose_up_tree_hooks(entry[:fn], proc)
+    end
+
     private
 
     HIDDEN_RE = /^_/
@@ -204,5 +206,35 @@ module Syntropy
     def remove_entry_cache_keys(entry)
       entry[:cache_keys]&.each_key { @cache.delete(it) }.clear
     end
+
+    def compose_up_tree_hooks(path, proc)
+      parent = File.dirname(path)
+      proc = hook_wrap_if_exists(File.join(parent, '_hook.rb'), proc)
+      proc = error_handler_wrap_if_exists(File.join(parent, '_error.rb'), proc)
+      return proc if parent == @root
+
+      compose_up_tree_hooks(parent, proc)
+    end
+
+    def hook_wrap_if_exists(hook_fn, proc)
+      return proc if !File.file?(hook_fn)
+
+      ref = path_rel(hook_fn).gsub(/\.rb$/, '')
+      hook_proc = @module_loader.load(ref)
+      ->(req) { hook_proc.(req, proc) }
+    end
+
+    def error_handler_wrap_if_exists(error_handler_fn, proc)
+      return proc if !File.file?(error_handler_fn)
+
+      ref = path_rel(error_handler_fn).gsub(/\.rb$/, '')
+      error_proc = @module_loader.load(ref)
+
+      proc do |req|
+        proc.(req)
+      rescue StandardError => e
+        error_proc.(req, e)
+      end
+    end
   end
 end

data/lib/syntropy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Syntropy
-  VERSION = '0.5'
+  VERSION = '0.6'
 end

data/test/app/_hook.rb

@@ -0,0 +1,5 @@
+export ->(req, proc) {
+  req.ctx[:foo] = req.query[:foo]
+  # p proc: proc
+  proc.(req)
+}

data/test/app/about/_error.rb

@@ -0,0 +1,6 @@
+DEFAULT_STATUS = Qeweney::Status::INTERNAL_SERVER_ERROR
+
+export ->(req, err) {
+  status = err.respond_to?(:http_status) ? err.http_status : DEFAULT_STATUS
+  req.respond("<h1>#{err.message}</h1>", ':status' => status, 'Content-Type' => 'text/html')
+}

data/test/app/about/raise.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  raise 'Raised error'
+}

data/test/test_app.rb

@@ -140,6 +140,18 @@ class AppTest < Minitest::Test
   ensure
     IO.write(@tmp_fn, orig_body) if orig_body
   end
+
+  def test_middleware
+    req = make_request(':method' => 'HEAD', ':path' => '/test?foo=42')
+    assert_equal Status::OK, req.response_status
+    assert_nil req.response_body
+    assert_equal '42', req.ctx[:foo]
+
+    req = make_request(':method' => 'HEAD', ':path' => '/test/about/raise?foo=43')
+    assert_equal Status::INTERNAL_SERVER_ERROR, req.response_status
+    assert_equal '<h1>Raised error</h1>', req.response_body
+    assert_equal '43', req.ctx[:foo]
+  end
 end
 
 class CustomAppTest < Minitest::Test

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: syntropy
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: '0.6'
 platform: ruby
 authors:
 - Sharon Rosner
@@ -202,12 +202,15 @@ files:
 - lib/syntropy/side_run.rb
 - lib/syntropy/version.rb
 - syntropy.gemspec
+- test/app/_hook.rb
 - test/app/_layout/default.rb
 - test/app/_lib/callable.rb
 - test/app/_lib/klass.rb
 - test/app/_lib/missing-export.rb
+- test/app/about/_error.rb
 - test/app/about/foo.md
 - test/app/about/index.rb
+- test/app/about/raise.rb
 - test/app/api+.rb
 - test/app/assets/style.css
 - test/app/bar.rb