syntropy 0.4 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50c0c34b9bdad39e7116f404c5d4efa7a8a79aa5911e95432efc62c8c90e6592
-  data.tar.gz: 72e0cb6947b187628e86be0af3f8fd5440c79f5c862b614e7074b45ae4dabf60
+  metadata.gz: 7f125135bc3ed83c1050467241f48caf366600fead1d75db79455038e42e311a
+  data.tar.gz: ee9bd2bbf906eea9c90481ecdf643126285f65f63fe66a3f2b4f3050893e7c28
 SHA512:
-  metadata.gz: f83fa7756c09e12eb87bea546142881d0dba682f214fcaa8ea78b865756232952d8d5a87c308cea0a4d39c4f608a101983c5a11807e99754b3efa19aadd61cad
-  data.tar.gz: 244d7a878c2e83e2a7ebfc5c0e4a7cd30b429497c7456211a80306ec2b2c3996050111c11dd71e54e9ca63b81e7d14e9475d528127b7d8538255b73e75ad50de
+  metadata.gz: 0bdce31c490701521d73829c02e1193fcd0da399b1e6186066ad5d6ecfa067dc143941300bf670fa4b447d5d5c177e903fa273d9d6d5bbfa2319ec0c74fd2678
+  data.tar.gz: 7b5eddf105f8654f379bf1d7f52948b713ee342dbd97eb1896e28b618b442ccf33c716d27a7f67c21cfd2c65f610b5c9677cd5e4faa0e777b8f727552628865c

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.5 2025-07-05
+
+- Refactor App class to use Router
+- Refactor routing functionality into separate Router class
+- Add support for _site.rb file
+
 ## 0.4 2025-07-03
 
 - Improve errors API

data/TODO.md

@@ -1,7 +1,30 @@
+- 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
 
   ```Ruby
-  # site/_middleware.rb or site/_hook.rb
+  # site/_hook.rb
   export ->(req, &app) do
     app.call(req)
   rescue Syntropy::Error => e
@@ -15,9 +38,32 @@
   export ->(req, err) do
     render_error_page(req, err.http_status)
   end
+
+  # a _site.rb file can be used to wrap a whole app
+  # site/_site.rb
+
+  # this means we route according to the host header, with each
+  export Syntropy.route_by_host
+
+  # we can also rewrite requests:
+  rewriter = Syntropy
+    .select { it.host =~ /^tolkora\.(org|com)$/ }
+    .terminate { it.redirect_permanent('https://tolkora.net') }
+
+  # This is actuall a pretty interesting DSL design:
+  # a chain of operations that compose functions. So, we can select a
+  export rewriter.wrap(default_app)
+
+  # composing
+  export rewriter.wrap(Syntropy.some_custom_app.wrap(app))
+
+  # or maybe
+  export rewriter << some_other_middleware << app
   ```
 
 
+
+
 - CLI tool for setting up a site repo:
 
   ```bash

data/bin/syntropy

@@ -61,5 +61,5 @@ end
 opts[:machine] = Syntropy.machine = UM.new
 opts[:logger] = opts[:logger] && TP2::Logger.new(opts[:machine], **opts)
 
-app = Syntropy::App.new(opts[:machine], opts[:location], '/', opts)
+app = Syntropy::App.load(opts)
 TP2.run(opts) { app.call(it) }

data/lib/syntropy/app.rb

@@ -12,38 +12,46 @@ require 'syntropy/module'
 
 module Syntropy
   class App
-    attr_reader :route_cache
+    class << self
+      def load(opts)
+        site_file_app(opts) || default_app(opts)
+      end
+
+      private
+
+      def site_file_app(opts)
+        site_fn = File.join(opts[:location], '_site.rb')
+        return nil if !File.file?(site_fn)
+
+        loader = Syntropy::ModuleLoader.new(opts[:location], opts)
+        loader.load('_site')
+      end
+
+      def default_app(opts)
+        new(opts[:machine], opts[:location], opts[:mount_path] || '/', opts)
+      end
+    end
 
     def initialize(machine, src_path, mount_path, opts = {})
       @machine = machine
       @src_path = File.expand_path(src_path)
       @mount_path = mount_path
-      @route_cache = {}
       @opts = opts
 
-      @relative_path_re = calculate_relative_path_re(mount_path)
+      @module_loader = Syntropy::ModuleLoader.new(@src_path, @opts)
+      @router = Syntropy::Router.new(@opts, @module_loader)
+
       @machine.spin do
         # we do startup stuff asynchronously, in order to first let TP2 do its
         # setup tasks
         @machine.sleep 0.15
         @opts[:logger]&.call("Serving from #{File.expand_path(@src_path)}")
-        start_file_watcher if opts[:watch_files]
+        @router.start_file_watcher if opts[:watch_files]
       end
-
-      @module_loader ||= Syntropy::ModuleLoader.new(@src_path, @opts)
-    end
-
-    def find_route(path, cache: true)
-      cached = @route_cache[path]
-      return cached if cached
-
-      entry = calculate_route(path)
-      @route_cache[path] = entry if entry[:kind] != :not_found && cache
-      entry
     end
 
     def call(req)
-      entry = find_route(req.path)
+      entry = @router[req.path]
       render_entry(req, entry)
     rescue Syntropy::Error => e
       msg = e.message
@@ -56,105 +64,6 @@ module Syntropy
 
     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)
-      @module_loader.unload(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 == '/'
-      %r{^#{mount_path}(?:/(.*))?$}
-    end
-
-    FILE_KINDS = {
-      '.rb' => :module,
-      '.md' => :markdown
-    }
-    NOT_FOUND = { kind: :not_found }
-
-    # We don't allow access to path with /.., or entries that start with _
-    FORBIDDEN_RE = %r{(/_)|((/\.\.)/?)}
-
-    def calculate_route(path)
-      return NOT_FOUND if path =~ FORBIDDEN_RE
-
-      m = path.match(@relative_path_re)
-      return NOT_FOUND if !m
-
-      relative_path = m[1] || ''
-      fs_path = File.join(@src_path, relative_path)
-
-      return file_entry(fs_path) if File.file?(fs_path)
-      return find_index_entry(fs_path) if File.directory?(fs_path)
-
-      entry = find_file_entry_with_extension(fs_path)
-      return entry if entry[:kind] != :not_found
-
-      find_up_tree_module(path)
-    end
-
-    def file_entry(fn)
-      { fn: File.expand_path(fn), kind: FILE_KINDS[File.extname(fn)] || :static }
-    end
-
-    def find_index_entry(dir)
-      find_file_entry_with_extension(File.join(dir, 'index'))
-    end
-
-    def find_file_entry_with_extension(path)
-      fn = "#{path}.html"
-      return file_entry(fn) if File.file?(fn)
-
-      fn = "#{path}.md"
-      return file_entry(fn) if File.file?(fn)
-
-      fn = "#{path}.rb"
-      return file_entry(fn) if File.file?(fn)
-
-      fn = "#{path}+.rb"
-      return file_entry(fn) if File.file?(fn)
-
-      NOT_FOUND
-    end
-
-    def find_up_tree_module(path)
-      parent = parent_path(path)
-      return NOT_FOUND if !parent
-
-      entry = find_route("#{parent}+.rb", cache: false)
-      entry[:kind] == :module ? entry : NOT_FOUND
-    end
-
-    UP_TREE_PATH_RE = %r{^(.+)?/[^/]+$}
-
-    def parent_path(path)
-      m = path.match(UP_TREE_PATH_RE)
-      m && m[1]
-    end
-
     def render_entry(req, entry)
       case entry[:kind]
       when :not_found
@@ -199,13 +108,13 @@ module Syntropy
     end
 
     def respond_module(req, entry)
-      entry[:code] ||= load_module(entry)
-      if entry[:code] == :invalid
+      entry[:proc] ||= load_module(entry)
+      if entry[:proc] == :invalid
         req.respond(nil, ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
         return
       end
 
-      entry[:code].call(req)
+      entry[:proc].call(req)
     rescue Syntropy::Error => e
       req.respond(nil, ':status' => e.http_status)
     rescue StandardError => e

data/lib/syntropy/file_watch.rb

@@ -8,15 +8,16 @@ module Syntropy
 
     queue = Thread::Queue.new
     listener = Listen.to(*roots) do |modified, added, removed|
-      fns = (modified + added + removed).uniq
-      fns.each { queue.push(it) }
+      modified.each { queue.push([:modified, it]) }
+      added.each    { queue.push([:added, it]) }
+      removed.each  { queue.push([:removed, it]) }
     end
     listener.start
 
     loop do
       machine.sleep(period) while queue.empty?
-      fn = queue.shift
-      block.call(fn)
+      event, fn = queue.shift
+      block.call(event, fn)
     end
   rescue StandardError => e
     p e

data/lib/syntropy/module.rb

@@ -15,7 +15,7 @@ module Syntropy
       @loaded[ref] ||= load_module(ref)
     end
 
-    def unload(fn)
+    def invalidate(fn)
       ref = @fn_map[fn]
       return if !ref
 

data/lib/syntropy/router.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Syntropy
+  class Router
+    attr_reader :cache
+
+    def initialize(opts, module_loader = nil)
+      raise 'Invalid location given' if !File.directory?(opts[:location])
+
+      @opts = opts
+      @machine = opts[:machine]
+      @root = File.expand_path(opts[:location])
+      @mount_path = opts[:mount_path] || '/'
+      @rel_path_re ||= /^#{@root}/
+      @module_loader = module_loader
+
+      @cache        = {} # maps url path to route entry
+      @routes       = {} # maps canonical path to route entry (actual routes)
+      @files        = {} # maps filename to entry
+      @deps         = {} # maps filenames to array of dependent entries
+      @x  = {} # maps directories to hook chains
+
+      scan_routes
+    end
+
+    def [](path)
+      get_route_entry(path)
+    end
+
+    def start_file_watcher
+      @opts[:logger]&.call('Watching for file changes...', nil)
+      @machine.spin { file_watcher_loop }
+    end
+
+    private
+
+    HIDDEN_RE = /^_/
+
+    def scan_routes(dir = nil)
+      dir ||= @root
+
+      Dir[File.join(dir, '*')].each do
+        basename = File.basename(it)
+        next if (basename =~ HIDDEN_RE)
+
+        File.directory?(it) ? scan_routes(it) : add_route(it)
+      end
+    end
+
+    def add_route(fn)
+      kind = route_kind(fn)
+      rel_path = path_rel(fn)
+      canonical_path = path_canonical(rel_path, kind)
+      entry = { kind:, fn:, canonical_path: }
+      entry[:handle_subtree] = true if (kind == :module) && !!(fn =~ /\+\.rb$/)
+
+      @routes[canonical_path] = entry
+      @files[fn] = entry
+    end
+
+    def route_kind(fn)
+      case File.extname(fn)
+      when '.md'
+        :markdown
+      when '.rb'
+        :module
+      else
+        :static
+      end
+    end
+
+    def path_rel(path)
+      path.gsub(@rel_path_re, '')
+    end
+
+    def path_abs(path, base)
+      File.join(base, path)
+    end
+
+    PATH_PARENT_RE = /^(.+)?\/([^\/]+)$/
+
+    def path_parent(path)
+      return nil if path == '/'
+
+      path.match(PATH_PARENT_RE)[1] || '/'
+    end
+
+    MD_EXT_RE = /\.md$/
+    RB_EXT_RE = /[+]?\.rb$/
+    INDEX_RE = /^(.*)\/index[+]?\.(?:rb|md|html)$/
+
+    def path_canonical(rel_path, kind)
+      clean = path_clean(rel_path, kind)
+      clean.empty? ? @mount_path : File.join(@mount_path, clean)
+    end
+
+    def path_clean(rel_path, kind)
+      if (m = rel_path.match(INDEX_RE))
+        return m[1]
+      end
+
+      case kind
+      when :static
+        rel_path
+      when :markdown
+        rel_path.gsub(MD_EXT_RE, '')
+      when :module
+        rel_path.gsub(RB_EXT_RE, '')
+      end
+    end
+
+    def get_route_entry(path, use_cache: true)
+      if use_cache
+        cached = @cache[path]
+        return cached if cached
+      end
+
+      entry = find_route_entry(path)
+      set_cache(path, entry) if use_cache && entry[:kind] != :not_found
+      entry
+    end
+
+    def set_cache(path, entry)
+      @cache[path] = entry
+      (entry[:cache_keys] ||= {})[path] = true
+    end
+
+    # We don't allow access to path with /.., or entries that start with _
+    FORBIDDEN_RE = %r{(/_)|((/\.\.)/?)}
+    NOT_FOUND = { kind: :not_found }.freeze
+
+    def find_route_entry(path)
+      return NOT_FOUND if path =~ FORBIDDEN_RE
+
+      @routes[path] || find_index_route(path) || find_up_tree_module(path) || NOT_FOUND
+    end
+
+    INDEX_OPT_EXT_RE = /^(.*)\/index(?:\.(?:rb|md|html))?$/
+
+    def find_index_route(path)
+      m = path.match(INDEX_OPT_EXT_RE)
+      return nil if !m
+
+      @routes[m[1]]
+    end
+
+    def find_up_tree_module(path)
+      parent_path = path_parent(path)
+      return nil if !parent_path
+
+      entry = @routes[parent_path]
+      return entry if entry && entry[:handle_subtree]
+
+      find_up_tree_module(parent_path)
+    end
+
+    def file_watcher_loop
+      wf = @opts[:watch_files]
+      period = wf.is_a?(Numeric) ? wf : 0.1
+      Syntropy.file_watch(@machine, @root, period: period) do |event, fn|
+        handle_changed_file(event, fn)
+      rescue Exception => e
+        p e
+        p e.backtrace
+        exit!
+      end
+    end
+
+    def handle_changed_file(event, fn)
+      @opts[:logger]&.call("Detected changed file: #{event} #{fn}")
+      @module_loader&.invalidate(fn)
+      case event
+      when :added
+        handle_added_file(fn)
+      when :removed
+        handle_removed_file(fn)
+      when :modified
+        handle_modified_file(fn)
+      end
+    end
+
+    def handle_added_file(fn)
+      add_route(fn)
+      @cache.clear # TODO: remove only relevant cache entries
+    end
+
+    def handle_removed_file(fn)
+      entry = @files[fn]
+      if entry
+        remove_entry_cache_keys(entry)
+        @routes.delete(entry[:canonical_path])
+        @files.delete(fn)
+      end
+    end
+
+    def handle_modified_file(fn)
+      entry = @files[fn]
+      if entry && entry[:kind] == :module
+        # invalidate the entry proc, so it will be recalculated
+        entry[:proc] = nil
+      end
+    end
+
+    def remove_entry_cache_keys(entry)
+      entry[:cache_keys]&.each_key { @cache.delete(it) }.clear
+    end
+  end
+end

data/lib/syntropy/version.rb

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

data/lib/syntropy.rb

@@ -9,11 +9,12 @@ require 'syntropy/connection_pool'
 require 'syntropy/module'
 require 'syntropy/rpc_api'
 require 'syntropy/side_run'
+require 'syntropy/router'
 require 'syntropy/app'
 require 'syntropy/request_extensions'
 
 module Syntropy
-    Status = Qeweney::Status
+  Status = Qeweney::Status
 
   class << self
     attr_accessor :machine

data/test/app_custom/_site.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  req.respond(nil, ':status' => Status::TEAPOT)
+}

data/test/test_app.rb

@@ -2,7 +2,7 @@
 
 require_relative 'helper'
 
-class AppRoutingTest < Minitest::Test
+class AppTest < Minitest::Test
   Status = Qeweney::Status
 
   APP_ROOT = File.join(__dir__, 'app')
@@ -13,48 +13,12 @@ class AppRoutingTest < Minitest::Test
     @tmp_path = '/test/tmp'
     @tmp_fn = File.join(APP_ROOT, 'tmp.rb')
 
-    @app = Syntropy::App.new(@machine, APP_ROOT, '/test', watch_files: 0.05)
-  end
-
-  def full_path(fn)
-    File.join(APP_ROOT, fn)
-  end
-
-  def test_find_route
-    entry = @app.find_route('/')
-    assert_equal :not_found, entry[:kind]
-
-    entry = @app.find_route('/test')
-    assert_equal :static, entry[:kind]
-    assert_equal full_path('index.html'), entry[:fn]
-
-    entry = @app.find_route('/test/about')
-    assert_equal :module, entry[:kind]
-    assert_equal full_path('about/index.rb'), entry[:fn]
-
-    entry = @app.find_route('/test/../test_app.rb')
-    assert_equal :not_found, entry[:kind]
-
-    entry = @app.find_route('/test/_layout/default')
-    assert_equal :not_found, entry[:kind]
-
-    entry = @app.find_route('/test/api')
-    assert_equal :module, entry[:kind]
-    assert_equal full_path('api+.rb'), entry[:fn]
-
-    entry = @app.find_route('/test/api/foo/bar')
-    assert_equal :module, entry[:kind]
-    assert_equal full_path('api+.rb'), entry[:fn]
-
-    entry = @app.find_route('/test/api/foo/../bar')
-    assert_equal :not_found, entry[:kind]
-
-    entry = @app.find_route('/test/api_1')
-    assert_equal :not_found, entry[:kind]
-
-    entry = @app.find_route('/test/about/foo')
-    assert_equal :markdown, entry[:kind]
-    assert_equal full_path('about/foo.md'), entry[:fn]
+    @app = Syntropy::App.load(
+      machine: @machine,
+      location: APP_ROOT,
+      mount_path: '/test',
+      watch_files: 0.05
+    )
   end
 
   def make_request(*, **)
@@ -131,6 +95,10 @@ class AppRoutingTest < Minitest::Test
     assert_equal({ status: 'Error', message: 'Teapot' }, req.response_json)
     assert_equal Status::TEAPOT, req.response_status
 
+    req = make_request(':method' => 'POST', ':path' => '/test/api/foo/bar?q=incr')
+    assert_equal({ status: 'Error', message: 'Teapot' }, req.response_json)
+    assert_equal Status::TEAPOT, req.response_status
+
     req = make_request(':method' => 'GET', ':path' => '/test/bar')
     assert_equal 'foobar', req.response_body
     assert_equal Status::OK, req.response_status
@@ -173,3 +141,30 @@ class AppRoutingTest < Minitest::Test
     IO.write(@tmp_fn, orig_body) if orig_body
   end
 end
+
+class CustomAppTest < Minitest::Test
+  Status = Qeweney::Status
+
+  APP_ROOT = File.join(__dir__, 'app_custom')
+
+  def setup
+    @machine = UM.new
+    @app = Syntropy::App.load(
+      machine: @machine,
+      location: APP_ROOT,
+      mount_path: '/'
+    )
+  end
+
+  def make_request(*, **)
+    req = mock_req(*, **)
+    @app.call(req)
+    req
+  end
+
+  def test_app_with_site_rb_file
+    req = make_request(':method' => 'GET', ':path' => '/foo/bar')
+    assert_nil req.response_body
+    assert_equal Status::TEAPOT, req.response_status
+  end
+end

data/test/test_file_watch.rb

@@ -14,21 +14,21 @@ class FileWatchTest < Minitest::Test
     queue = UM::Queue.new
 
     f = @machine.spin do
-      Syntropy.file_watch(@machine, @root, period: 0.01) { @machine.push(queue, it) }
+      Syntropy.file_watch(@machine, @root, period: 0.01) { |event, fn| @machine.push(queue, [event, fn]) }
     end
     @machine.sleep(0.05)
     assert_equal 0, queue.count
 
     fn = File.join(@root, 'foo.bar')
     IO.write(fn, 'abc')
-    assert_equal fn, @machine.shift(queue)
+    assert_equal [:added, fn], @machine.shift(queue)
 
     fn = File.join(@root, 'foo.bar')
     IO.write(fn, 'def')
-    assert_equal fn, @machine.shift(queue)
+    assert_equal [:modified, fn], @machine.shift(queue)
 
     FileUtils.rm(fn)
-    assert_equal fn, @machine.shift(queue)
+    assert_equal [:removed, fn], @machine.shift(queue)
   ensure
     @machine.schedule(f, UM::Terminate)
     # @machine.join(f)

data/test/test_router.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class RouterTest < Minitest::Test
+  APP_ROOT = File.join(__dir__, 'app')
+
+  def setup
+    @machine = UM.new
+
+    @tmp_path = '/test/tmp'
+    @tmp_fn = File.join(APP_ROOT, 'tmp.rb')
+
+    @router = Syntropy::Router.new(
+      machine: @machine,
+      location: APP_ROOT,
+      mount_path: '/test',
+      watch_files: 0.05
+    )
+    @router.start_file_watcher
+  end
+
+  def full_path(fn)
+    File.join(APP_ROOT, fn)
+  end
+
+  def test_find_route
+    # entry = @router['/']
+    # assert_equal :not_found, entry[:kind]
+
+    entry = @router['/test']
+    assert_equal :static, entry[:kind]
+    assert_equal full_path('index.html'), entry[:fn]
+
+    entry = @router['/test/about']
+    assert_equal :module, entry[:kind]
+    assert_equal full_path('about/index.rb'), entry[:fn]
+
+    entry = @router['/test/../test_app.rb']
+    assert_equal :not_found, entry[:kind]
+
+    entry = @router['/test/_layout/default']
+    assert_equal :not_found, entry[:kind]
+
+    entry = @router['/test/api']
+    assert_equal :module, entry[:kind]
+    assert_equal full_path('api+.rb'), entry[:fn]
+
+    entry = @router['/test/api/foo/bar']
+    assert_equal :module, entry[:kind]
+    assert_equal full_path('api+.rb'), entry[:fn]
+
+    entry = @router['/test/api/foo/../bar']
+    assert_equal :not_found, entry[:kind]
+
+    entry = @router['/test/api_1']
+    assert_equal :not_found, entry[:kind]
+
+    entry = @router['/test/about/foo']
+    assert_equal :markdown, entry[:kind]
+    assert_equal full_path('about/foo.md'), entry[:fn]
+  end
+
+  def test_router_file_watching
+    @machine.sleep 0.2
+
+    entry = @router[@tmp_path]
+    assert_equal :module, entry[:kind]
+
+    # remove file
+    orig_body = IO.read(@tmp_fn)
+    FileUtils.rm(@tmp_fn)
+    @machine.sleep(0.3)
+
+    entry = @router[@tmp_path]
+    assert_equal :not_found, entry[:kind]
+
+    IO.write(@tmp_fn, 'foobar')
+    @machine.sleep(0.3)
+    entry = @router[@tmp_path]
+    assert_equal :module, entry[:kind]
+
+    entry[:proc] = ->(x) { x }
+    IO.write(@tmp_fn, 'barbaz')
+    @machine.sleep(0.3)
+    assert_nil entry[:proc]
+  ensure
+    IO.write(@tmp_fn, orig_body) if orig_body
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: syntropy
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: '0.5'
 platform: ruby
 authors:
 - Sharon Rosner
@@ -197,6 +197,7 @@ files:
 - lib/syntropy/file_watch.rb
 - lib/syntropy/module.rb
 - lib/syntropy/request_extensions.rb
+- lib/syntropy/router.rb
 - lib/syntropy/rpc_api.rb
 - lib/syntropy/side_run.rb
 - lib/syntropy/version.rb
@@ -213,12 +214,14 @@ files:
 - test/app/baz.rb
 - test/app/index.html
 - test/app/tmp.rb
+- test/app_custom/_site.rb
 - test/helper.rb
 - test/run.rb
 - test/test_app.rb
 - test/test_connection_pool.rb
 - test/test_file_watch.rb
 - test/test_module.rb
+- test/test_router.rb
 - test/test_rpc_api.rb
 - test/test_side_run.rb
 - test/test_validation.rb