syntropy 0.4 → 0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50c0c34b9bdad39e7116f404c5d4efa7a8a79aa5911e95432efc62c8c90e6592
-  data.tar.gz: 72e0cb6947b187628e86be0af3f8fd5440c79f5c862b614e7074b45ae4dabf60
+  metadata.gz: 553553edc3b0c81902bc3a77470bc6e9789fcd757066dcd5b4e790d38f7a28bf
+  data.tar.gz: fdb2cec5f581ba49d5156cce188f31a4811d29767c71833bfcfa37899ee0efc5
 SHA512:
-  metadata.gz: f83fa7756c09e12eb87bea546142881d0dba682f214fcaa8ea78b865756232952d8d5a87c308cea0a4d39c4f608a101983c5a11807e99754b3efa19aadd61cad
-  data.tar.gz: 244d7a878c2e83e2a7ebfc5c0e4a7cd30b429497c7456211a80306ec2b2c3996050111c11dd71e54e9ca63b81e7d14e9475d528127b7d8538255b73e75ad50de
+  metadata.gz: 7340ecb01725dcc15a78a66fef5f87a113c2e9759a2305753241b0c1cf738f45b3fd6fea2dcf7bca55196cc3fc309db2ade3e7bb12292fc5aa3abe63362403f9
+  data.tar.gz: 48427e653e2c99022177e5475ef53b66c57143288f43e4997c40f1ba464728b310c5e0df343e7f03e3ed79f9fa8637e305b6a22296b19fb15068b7228cf0531f

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.6 2025-07-05
+
+- Add support for middleware and error handlers
+
+## 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,23 +1,58 @@
-- Middleware
+- Some standard middleware:
+
+  - request rewriter
+  - logger
+  - auth
+  - selector + terminator
 
   ```Ruby
-  # site/_middleware.rb or 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
+
+  # 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,121 +64,33 @@ 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
+    def render_entry(req, entry)
+      kind = entry[:kind]
+      return respond_not_found(req) if kind == :not_found
 
-      entry = find_route("#{parent}+.rb", cache: false)
-      entry[:kind] == :module ? entry : NOT_FOUND
+      entry[:proc] ||= calculate_route_proc(entry)
+      entry[:proc].(req)
     end
 
-    UP_TREE_PATH_RE = %r{^(.+)?/[^/]+$}
-
-    def parent_path(path)
-      m = path.match(UP_TREE_PATH_RE)
-      m && m[1]
+    def calculate_route_proc(entry)
+      render_proc = route_render_proc(entry)
+      @router.calc_route_proc_with_hooks(entry, render_proc)
     end
 
-    def render_entry(req, entry)
+    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'
@@ -199,13 +119,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,240 @@
+# frozen_string_literal: true
+
+module Syntropy
+  class Router
+    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
+
+    def calc_route_proc_with_hooks(entry, proc)
+      compose_up_tree_hooks(entry[:fn], proc)
+    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
+
+    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.4'
+  VERSION = '0.6'
 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/_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/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
@@ -172,4 +140,43 @@ class AppRoutingTest < 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
+  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.6'
 platform: ruby
 authors:
 - Sharon Rosner
@@ -197,28 +197,34 @@ 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
 - 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
 - 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