syntropy 0.36.0 → 0.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f92ed1375642f12fb92654d872bfde1d07c7ad74be97507af3c1616390b6ce14
-  data.tar.gz: 5072d514bc07149f1d26bc900bcc9379970ebbbaf1b88eaa23933189fb684b37
+  metadata.gz: 85989e43beae58a319d108e1c8cf42f8265fdfaa0675c0fa2b0b8c8df5dbfbd1
+  data.tar.gz: cd2dd5db7add2b3e3aa74f2a3fa02da3c1896b808a46be16b088e264875aec10
 SHA512:
-  metadata.gz: f77aed02801a7b1c10f67a5ed7fbac9196580bd482c19ca660c81beaf5f2adcba86047635e35f9750d003538b12401962888193c058fbc3023ae88eae9038506
-  data.tar.gz: f923ab3aa4e535d5a85a563acf7f97534639ca1ed3d02e2c2b94d9cecef57e06cefc3a72a1ca782d0118b012189298bc3c743b017c0ee2d06be8bbf55d03dc89
+  metadata.gz: 3cd0fb5d085456bc8d51db049fecaf11f000071cde6b19dd224c7ec422e1fb749be3ba92dfd5b8a43e3e95313f99b1ffed5f926ca37abd5377e2badd249576f3
+  data.tar.gz: c3a2b789fe2c9cfbff79b2245381f3ee76bad2e905e3f8408df2666af1495b51f93988d7085c1957330b194237f366e0999b43eb25b8e0e42954f07146aaa5cb

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+# 0.38.0 2026-06-13
+
+- Reimplement controller extensions: `dispatch_by_host`,
+  `dispatch_by_http_method`
+- Fix middleware composition
+- Add CLI command shortcuts
+- Rename `Syntropy::Module` to `Syntropy::ModuleContext`
+
+# 0.37.0 2026-06-07
+
+- Call `IO#clear` before closing server connection
+- syntropy new:
+  - Remove socket mapping for backend in docker-compose.yml
+  - Add caddy reverse proxy to template
+  - Add overwrite confirmation, better file copying
+- Verify storage module `migrate!` method exists
+- Fix `set_schema_version` for usage in PG DB
+- Do not raise exception on missing config module
+- Do not convert class export value to class instance, allow exporting a
+  class
+- Fix HTTP protocol error when pipelining post requests with empty body
+- Setup fiber scheduler when running server
+
 # 0.36.0 2026-06-04
 
 - Rename `DB` to `Storage`

data/Gemfile

@@ -1,3 +1,7 @@
 source 'https://gem.coop'
 
 gemspec
+
+group :development do
+  gem 'roda'
+end

data/TODO.md

@@ -1,5 +1,9 @@
 ## Immediate
 
+- [ ] Controllers
+  - [ ] Streamline names of ready-made control methods:
+    - [ ] dispatch_json_rpc
+
 - [ ] Collection - treat directories and files as collections of data.
 
   Kind of similar to the routing tree, but instead of routes it just takes a

data/bin/syntropy

@@ -1,13 +1,23 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require_relative '../cmd/_banner'
-
 def cmd_fn(cmd)= File.join(__dir__, "../cmd/#{cmd}.rb")
 
 cmd = ARGV.shift || 'help'
 cmd = 'help' if cmd !~ /^[a-z]+$/
 
+SHORTCUTS = {
+  'c' => 'console',
+  'n' => 'new',
+  's' => 'serve',
+  't' => 'test',
+  'v' => 'version'
+}
+
+if (target_cmd = SHORTCUTS[cmd])
+  cmd = target_cmd
+end
+
 fn = cmd_fn(cmd)
 fn = cmd_fn('help') if !File.file?(fn)
 

data/cmd/help.rb

@@ -5,8 +5,12 @@ HELP = <<~MSG
 
   Available commands:
 
+    console   Start an IRB session
+    help      Show this message
+    new       Create a new Syntropy app
     serve     Start a Syntropy server
     test      Run tests
+    version   Show version information
 MSG
 
 $stdout << HELP

data/cmd/new/template/.gitignore

@@ -1,3 +1,4 @@
 Gemfile.lock
-storage/*
+storage/*.db*
+storage/caddy/*
 vendor/bundle

data/cmd/new/template/config/Caddyfile

@@ -0,0 +1,5 @@
+localhost {
+  reverse_proxy app_server:1234
+  tls internal
+  encode
+}

data/cmd/new/template/docker-compose.yml

@@ -7,17 +7,18 @@ services:
       - seccomp:unconfined
     volumes:
       - .:/syntropy
-    ports:
-      - "1234:1234"
     stop_signal: SIGINT
     stop_grace_period: 10s
-    restart: always
+    restart: unless-stopped
     healthcheck:
       test: "curl 'http://localhost:1234/'"
       interval: "30s"
       timeout: "3s"
       start_period: "5s"
       retries: 3
+    networks:
+      - proxy_network
+
   console:
     build: .
     command: bundle exec syntropy console
@@ -31,6 +32,7 @@ services:
       - .:/syntropy
     stop_signal: SIGINT
     restart: never
+
   test:
     build: .
     command: bundle exec syntropy test -w
@@ -44,3 +46,26 @@ services:
       - .:/syntropy
     stop_signal: SIGINT
     restart: never
+
+  proxy:
+    depends_on:
+      - app_server
+    image: caddy:2-alpine
+    build:
+      context: ./proxy
+      dockerfile: Dockerfile
+    restart: unless-stopped
+    ports:
+      - "80:80"
+      - "443:443"
+      - "443:443/udp"
+    volumes:
+      - ./config/Caddyfile:/etc/caddy/Caddyfile
+      - ./storage/caddy/data:/data
+      - ./storage/caddy/config:/config
+    networks:
+      - proxy_network
+
+networks:
+  proxy_network:
+    name: proxy_network

data/cmd/new.rb

@@ -3,9 +3,15 @@
 require 'optparse'
 require 'fileutils'
 
+opts = {}
+
 parser = OptionParser.new do |o|
   o.banner = 'Usage: syntropy new NAME [options]'
 
+  o.on('-y', '--yes', 'Confirm all overwrites') do
+    opts[:yes] = true
+  end
+
   o.on('-h', '--help', 'Show this help message') do
     puts o
     exit
@@ -37,7 +43,7 @@ template_path = File.join(__dir__, 'new/template')
 
 begin
   `mkdir -p "#{path}"`
-  `cp -r #{template_path}/* "#{path}/"`
+  system("cp -rv#{opts[:yes] ? '' : 'i'} #{template_path}/* \"#{path}/\"")
   puts "Your app is ready in #{path}"
 rescue => e
   p e

data/cmd/serve.rb

@@ -94,7 +94,9 @@ env[:banner] = false
 env[:machine] = Syntropy.machine = UM.new
 env[:logger] = env[:logger] && Syntropy::Logger.new(env[:machine], **env)
 
-require 'syntropy/version'
+require 'uringmachine/fiber_scheduler'
+Fiber.set_scheduler(UM::FiberScheduler.new(env[:machine]))
+
 require 'syntropy/dev_mode' if Syntropy.dev_mode
 
 app = Syntropy::App.load(env)

data/cmd/version.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'syntropy/version'
+require 'uringmachine/version'
+require_relative './_banner'
+
+VERSION = <<~MSG
+      Syntropy version #{Syntropy::VERSION}
+  UringMachine version #{UringMachine::VERSION}
+          Ruby version #{RUBY_VERSION}
+MSG
+
+$stdout << SYNTROPY_BANNER
+$stdout << VERSION

data/examples/basic/counter_api.rb

@@ -19,4 +19,4 @@ class CounterAPI < Syntropy::JSONAPI
   end
 end
 
-export CounterAPI
+export CounterAPI.new(@env)

data/examples/blog/app/posts/[id]/edit.rb

@@ -1,7 +1,7 @@
 @posts = import '/_lib/posts'
 @layout = import '/_layout/default'
 
-export http_methods
+export dispatch_by_http_method
 
 def get(req)
   id = req.route_params['id'].to_i

data/examples/blog/app/posts/[id]/index.rb

@@ -1,7 +1,7 @@
 @posts = import '/_lib/posts'
 @layout = import '/_layout/default'
 
-export http_methods
+export dispatch_by_http_method
 
 def get(req)
   id = req.route_params['id'].to_i

data/examples/blog/app/posts/index.rb

@@ -1,7 +1,7 @@
 @posts = import '_lib/posts'
 @layout = import '_layout/default'
 
-export http_methods
+export dispatch_by_http_method
 
 def get(req)
   posts = @posts.get_all

data/examples/blog/app/posts/new.rb

@@ -1,7 +1,7 @@
 @posts = import '/_lib/posts'
 @layout = import '/_layout/default'
 
-export http_methods
+export dispatch_by_http_method
 
 def get(req)
   req.respond_html(

data/lib/syntropy/app.rb

@@ -9,6 +9,7 @@ require 'syntropy/errors'
 require 'syntropy/module_loader'
 require 'syntropy/routing_tree'
 require 'syntropy/mime_types'
+require 'syntropy/controller_extensions'
 
 module Syntropy
   # The App implements a Syntropy application. It is responsible for handling
@@ -34,7 +35,7 @@ module Syntropy
         fn = File.join(env[:app_root], '_site.rb')
         return nil if !File.file?(fn)
 
-        loader = Syntropy::ModuleLoader.new(env)
+        loader = Syntropy::ModuleLoader.new(env, extensions: ControllerExtensions)
         loader.load('_site')
       end
 
@@ -61,7 +62,10 @@ module Syntropy
       @env = env
       @logger = env[:logger]
 
-      @module_loader = Syntropy::ModuleLoader.new(app: self, **env)
+      @module_loader = Syntropy::ModuleLoader.new(
+        env.merge(app: self),
+        extensions: ControllerExtensions
+      )
       setup_routing_tree
       start
     end

data/lib/syntropy/controller_extensions.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Syntropy
+  # Utilities for use in modules
+  module ControllerExtensions
+    # Returns a unique temporary path
+    #
+    # @param prefix [String] temp file prefix
+    # @return [String]
+    def tmp_path(prefix = 'syntropy')
+      "/tmp/#{prefix}-#{SecureRandom.hex(16)}"
+    end
+
+    # Returns a request handler that routes request according to the host
+    # header. Looks for site directories (named by host name) in the app's root
+    # directory. A map may be given in order to provide additional hostnames to
+    # site directories.
+    #
+    # @param dir [String, nil] relative directory path for host sites
+    # @param map [Hash, nil] hash mapping host names to relative site directory
+    # @return [Proc] router proc
+    def dispatch_by_host(dir = nil, map = nil)
+      raise Syntropy::Error, 'Must provide dir and/or map' if !dir && !map
+
+      site_map = {}
+      setup_directory_sites(dir, site_map) if dir
+      setup_mapped_sites(map, site_map) if map
+
+      ->(req) do
+        site = site_map[req.host]
+        site ? site.call(req) : req.respond(nil, ':status' => HTTP::BAD_REQUEST)
+      end
+    end
+
+    # Returns a request handler that handles requests by calling the appropriate
+    # module method (e.g. get, post, etc.)
+    #
+    # @return [Proc]
+    def dispatch_by_http_method
+      ->(req) do
+        route_by_http_method(req)
+      end
+    end
+
+    # Returns a list of parsed markdown pages at the given path.
+    #
+    # @param env [Hash] app environment hash
+    # @param ref [String] directory path
+    # @return [Array<Hash>] array of page entries
+    def page_list(env, ref)
+      full_path = File.join(env[:app_root], ref)
+      raise 'Not a directory' if !File.directory?(full_path)
+
+      Dir[File.join(full_path, '*.md')].sort.map {
+        atts, markdown = Syntropy::Markdown.parse(it, env)
+        { atts:, markdown: }
+      }
+    end
+
+    # Instantiates a Syntropy app for the given environment hash.
+    #
+    # @return [Syntropy::App]
+    def app(**)
+      Syntropy::App.new(**)
+    end
+
+    BUILTIN_APPLET_app_root = File.expand_path(File.join(__dir__, 'applets/builtin'))
+
+    # Creates a builtin applet with the given environment hash. By default the
+    # builtin applet is mounted at /.syntropy.
+    #
+    # @param env [Hash] app environment
+    # @param mount_path [String] mount path for the builtin applet
+    # @return [Syntropy::App] applet
+    def builtin_applet(env, mount_path: '/.syntropy')
+      app(
+        machine:    env[:machine],
+        app_root:   BUILTIN_APPLET_app_root,
+        mount_path: mount_path,
+        builtin_applet_path: nil,
+        watch_files: nil
+      )
+    end
+
+    private
+
+    # Finds sites in the root directory for the given environment hash, adds
+    # entries to the given site map.
+    #
+    # @param dir [String] relative or absolute path
+    # @param site_map [Hash] site map
+    # @return [void]
+    def setup_directory_sites(ref, site_map)
+      app_root = @app ? @app.app_root : @env[:app_root]
+      ref = normalize_import_ref(ref)
+
+      Dir[File.join(app_root, ref, '*')]
+        .select { File.directory?(it) && File.basename(it) !~ /^_/ }
+        .each { |entry| site_map[File.basename(entry)] = make_app(entry) }
+    end
+
+    # converts the given map entries by adding entries to the given site map.
+    #
+    # @param map [Hash] ref map
+    # @param site_map [Hash] site map
+    # @return [void]
+    def setup_mapped_sites(map, site_map)
+      app_root = @app ? @app.app_root : @env[:app_root]
+      map.each do |name, ref|
+        ref = File.join(File.dirname(@ref), ref) if ref !~ /^\//
+        site_root = File.join(app_root, ref)
+        site_map[name] = make_app(site_root)
+      end
+    end
+
+    # Creates an app loaded from the given root directory, with the present
+    # mount path.
+    def make_app(site_root)
+      mount_path = @ref == '/_site' ? '/' : @ref
+      env = @env.merge(app_root: site_root, mount_path:)
+      Syntropy::App.new(**env)
+    end
+
+    # Handles the given request by calling the module method corresponding to
+    # the request's HTTP method. If no method is found, raises a
+    # method_not_allowed error.
+    def route_by_http_method(req)
+      sym = req.method.to_sym
+      raise Syntropy::Error.method_not_allowed if !respond_to?(sym)
+
+      send(sym, req)
+    end
+  end
+end

data/lib/syntropy/http/io_extensions.rb

@@ -76,6 +76,9 @@ module Syntropy
       def http_read_body(headers)
         content_length = headers['content-length']
         if content_length
+          content_length = content_length.to_i
+          return nil if content_length == 0
+
           chunk = read(content_length.to_i)
           return chunk
         end
@@ -95,6 +98,9 @@ module Syntropy
       def http_skip_body(headers)
         content_length = headers['content-length']
         if content_length
+          content_length = content_length.to_i
+          return if content_length == 0
+
           return skip(content_length.to_i)
         end
 
@@ -110,6 +116,9 @@ module Syntropy
       def http_read_body_chunk(headers)
         content_length = headers['content-length']
         if content_length
+          content_length = content_length.to_i
+          return nil if content_length == 0
+
           chunk = read(content_length.to_i)
           return chunk
         end

data/lib/syntropy/http/server_connection.rb

@@ -39,6 +39,7 @@ module Syntropy
           error:    e
         )
       ensure
+        @io.clear
         @machine.close_async(@fd)
       end
 

data/lib/syntropy/json_api.rb

@@ -25,6 +25,11 @@ module Syntropy
         ':status'       => status,
         'Content-Type'  => 'application/json'
       )
+    rescue => e
+      puts '*' * 40
+      p e
+      p e.backtrace.join
+      puts
     end
 
     private

data/lib/syntropy/module_loader.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'papercraft'
+require 'syntropy/errors'
 
 module Syntropy
   # The ModuleLoader class implemenets a module loader. It handles loading of
@@ -25,12 +26,14 @@ module Syntropy
     # Instantiates a module loader
     #
     # @param env [Hash] environment hash
+    # @param extensions [Module, Array<Module>] extension module(s)
     # @return [void]
-    def initialize(env)
+    def initialize(env, extensions: nil)
       @env = env
       @app_root = env[:app_root]
       @modules = {} # maps ref to module entry
       @fn_map = {} # maps filename to ref
+      @extensions = extensions
     end
 
     # Loads a module (if not already loaded) and returns its export value.
@@ -131,7 +134,7 @@ module Syntropy
       @fn_map[fn] = ref
       code = IO.read(fn)
       env = @env.merge(module_loader: self, ref: clean_ref(ref))
-      mod = Syntropy::Module.load(env, code, fn)
+      mod = Syntropy::ModuleContext.load(env, code, fn, @extensions)
       add_dependencies(ref, mod.__dependencies__)
       export_value = transform_module_export_value(
         mod.__export_value__, fn, raise_on_missing:
@@ -150,10 +153,10 @@ module Syntropy
     # @param ref [String] input ref
     # @return [String] clean ref
     def clean_ref(ref)
-      return '/' if ref =~ /^index(\+)?$/
+      return '/' if ref =~ /^index[+]?$/
 
-      clean = ref.gsub(/\/index(?:\+)?$/, '')
-      clean == '' ? '/' : clean
+      clean = ref.gsub(/\/index[+]?$/, '')
+      (clean == '') ? '/' : clean
     end
 
     # Transforms the given export value. If the value is nil, an exception is
@@ -167,17 +170,15 @@ module Syntropy
         raise Syntropy::Error, "No export found in #{fn}" if raise_on_missing
       when String
         ->(req) { req.respond(export_value) }
-      when Class
-        export_value.new(@env)
       else
         export_value
       end
     end
   end
 
-  # The Syntropy::Module class implements a reloadable module. A module is a
-  # `.rb` source file that implements a route endpoint, a template, utility
-  # methods or any other functionality needed by the web app.
+  # The Syntropy::ModuleContext class provides a context for loading a module. A
+  # module is a `.rb` source file that implements a route endpoint, a template,
+  # utility methods or any other functionality needed by the web app.
   #
   # The following instance variables are available to modules:
   #
@@ -191,35 +192,45 @@ module Syntropy
   # In addition, the module code also has access to the `MODULE` constant which
   # is set to `self`, and may be used to refer to various methods defined in the
   # module.
-  class Module
+  class ModuleContext
     # Loads a module, returning the module instance
-    def self.load(env, code, fn)
-      m = new(**env)
-      m.instance_eval(code, fn)
+    # @param env [Hash] app environment
+    # @param code [String] module source code
+    # @param fn [String] module file name
+    # @param extensions [Module, Array<Module>] extension module(s)
+    # @return [Syntropy::ModuleContext] created module context
+    def self.load(env, code, fn, extensions)
+      mod = new(env)
+      apply_extensions(mod, extensions)
+      mod.instance_eval(code, fn)
       env[:logger]&.info(message: "Loaded module at #{fn}")
-      m
-    rescue SyntaxError => e
+      mod
+    rescue StandardError, SyntaxError => e
       env[:logger]&.error(message: "Error while loading module at #{fn}", error: e)
-      STDERR.puts("\n#{e.message}") if !Syntropy.test_mode
+      e.is_a?(SyntaxError) ? handle_syntax_error(env, e) : (raise e)
+    end
 
-      if (m = e.message.match(/^(.+)\: syntax/))
-        location = m[1]
-        e2 = SyntaxError.new("Syntax errors found in module #{env[:ref]}")
-        e2.set_backtrace([location] + e.backtrace)
-        raise e2
+    # Applies the given extension(s) to the given module context.
+    #
+    # @param mod [Syntropy::ModuleContext] module context
+    # @param extensions [Module, Array<Module>] extension module(s)
+    def self.apply_extensions(mod, extensions)
+      case extensions
+      when Array
+        extensions.each { mod.extend(it) }
+      when Module
+        mod.extend(extensions)
+      when nil # return
       else
-        raise e
+        raise Syntropy::Error, "Invalid module extensions: #{extensions.inspect}"
       end
-    rescue => e
-      env[:logger]&.error(message: "Error while loading module at #{fn}", error: e)
-      raise e
     end
 
     # Initializes a module with the given environment hash.
     #
     # @param env [Hash] environment hash
     # @return [void]
-    def initialize(**env)
+    def initialize(env)
       @env = env
       @machine = env[:machine]
       @module_loader = env[:module_loader]
@@ -331,22 +342,15 @@ module Syntropy
       Syntropy::App.new(**env)
     end
 
-    # Returns a request handler that handles requests by calling the appropriate
-    # module method (e.g. get, post, etc.)
-    #
-    # @return [Proc]
-    def http_methods
-      ->(req) { route_by_http_method(req) }
-    end
-
-    # Handles the given request by calling the module method corresponding to
-    # the request's HTTP method. If no method is found, raises a
-    # method_not_allowed error.
-    def route_by_http_method(req)
-      sym = req.method.to_sym
-      raise Syntropy::Error.method_not_allowed if !respond_to?(sym)
+    def handle_syntax_error(env, e)
+      $stderr.puts("\n#{e.message}") if !Syntropy.test_mode
+      m = e.message.match(/^(.+): syntax/)
+      raise e if !m
 
-      send(sym, req)
+      location = m[1]
+      e2 = SyntaxError.new("Syntax errors found in module #{env[:ref]}")
+      e2.set_backtrace([location] + e.backtrace)
+      raise e2
     end
   end
 end