syntropy 0.38.1 → 0.40.0

data/lib/syntropy/http/server_connection.rb

@@ -13,6 +13,14 @@ module Syntropy
     class ServerConnection
       attr_reader :fd, :response_headers, :logger
 
+      # Initializes a server connection.
+      #
+      # @param machine [UringMachine] machine instance
+      # @param fd [Integer] file descriptor
+      # @param env [Hash] app environment
+      # @param io_mode [Symbol] IO mode
+      # @param app [Proc, Syntropy::App] server app
+      # @return [void]
       def initialize(machine, fd, env, io_mode: :socket, &app)
         @machine = machine
         @fd = fd
@@ -26,6 +34,9 @@ module Syntropy
         @response_cookies = nil
       end
 
+      # Runs the connection.
+      #
+      # @return [void]
       def run
         loop do
           persist = serve_request
@@ -33,6 +44,10 @@ module Syntropy
         end
       rescue UM::Terminate
         # server is terminated, do nothing
+      rescue SystemCallError
+        @logger&.error(
+          message:  'IO Error, closing...'
+        )
       rescue StandardError => e
         @logger&.error(
           message:  'Uncaught error while running connection',
@@ -99,6 +114,10 @@ module Syntropy
         @logger&.error(message: "#{message}, closing connection", error: err)
       end
 
+      # Reads the request body.
+      #
+      # @param req [Syntropy::Request] request
+      # @return [String, nil] request body
       def get_body(req)
         headers = req.headers
         return nil if headers[':body-done-reading']
@@ -108,6 +127,10 @@ module Syntropy
         body
       end
 
+      # Reads a request body chunk.
+      #
+      # @param req [Syntropy::Request] request
+      # @return [String, nil] request body chunk
       def get_body_chunk(req)
         headers = req.headers
         return nil if headers[':body-done-reading']
@@ -117,6 +140,9 @@ module Syntropy
         chunk
       end
 
+      # Returns true if the request is done
+      #
+      # @return [bool] whether the request is complete
       def complete?(req)
         req.headers[':body-done-reading']
       end
@@ -135,6 +161,11 @@ module Syntropy
 
       DELETE_COOKIE = "; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Path=/; Max-Age=0; HttpOnly"
 
+      # Adds a Set-Cookie header to the response headers.
+      #
+      # @param key [String] cookie name
+      # @param value [String] cookie value
+      # @return [void]
       def set_cookie(key, value)
         (@response_cookies ||= {})[key] = value || DELETE_COOKIE
       end
@@ -210,6 +241,13 @@ module Syntropy
         @done = true
       end
 
+      # Responds by rendering a static file.
+      #
+      # @param req [Syntropy::Request] request
+      # @param path [String] file path
+      # @param env [Hash] app environment
+      # @param cache_headers [Hash] cache headers
+      # @return [void]
       def respond_with_static_file(req, path, env, cache_headers)
         fd = @machine.open(path, UM::O_RDONLY)
         env ||= {}
@@ -240,6 +278,9 @@ module Syntropy
         end
       end
 
+      # Closes the connection.
+      #
+      # @return [void]
       def close
         return if @closed
 
@@ -248,6 +289,9 @@ module Syntropy
         @machine.close_async(@fd)
       end
 
+      # Yields the uhnderlying connection IO and fd to the given block.
+      #
+      # @return [void]
       def with_stream
         yield @io, @fd
       end
@@ -260,6 +304,9 @@ module Syntropy
       MAX_HEADER_LINE_LEN = 1 << 10 # 1KB
       MAX_CHUNK_SIZE_LEN = 16
 
+      # Returns true if the connection should be persisted.
+      #
+      # @param headers [Hash] request headers
       def persist_connection?(headers)
         connection = headers['connection']&.downcase
         return connection != 'close'
@@ -285,14 +332,23 @@ module Syntropy
         lines
       end
 
+      # Formats a response status line.
+      #
+      # @param body [String] response body
+      # @param status [Integer] HTTP status code
+      # @return [String] rendered status line
       def format_status_line(body, status)
         if !body
           empty_status_line(status)
         else
-          with_body_status_line(status, body)
+          with_body_status_line(body, status)
         end
       end
 
+      # Returns the status line for an empty response.
+      #
+      # @param status [Integer] HTTP status code
+      # @return [String] rendered status line
       def empty_status_line(status)
         if status == 204
           +"HTTP/1.1 #{status}\r\n"
@@ -301,10 +357,21 @@ module Syntropy
         end
       end
 
-      def with_body_status_line(status, body)
+      # Returns a status line for responses with body.
+      #
+      # @param body [String] response body
+      # @param status [Integer] HTTP status code
+      # @return [String] rendered status line
+      def with_body_status_line(body, status)
         +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
       end
 
+      # Renders headers into a lines array.
+      #
+      # @param lines [Array<String>] array of header lines
+      # @param key [String] header name
+      # @param value [String, Array<String>] header value(s)
+      # @return [void]
       def collect_header_lines(lines, key, value)
         if value.is_a?(Array)
           value.inject(lines) { |_, item| lines << "#{key}: #{item}\r\n" }
@@ -313,6 +380,9 @@ module Syntropy
         end
       end
 
+      # Adds Set-Cookie headers to the response headers.
+      #
+      # @return [void]
       def add_set_cookie_headers
         @response_headers ||= {}
         sc = (@response_headers['Set-Cookie'] ||= [])

data/lib/syntropy/logger.rb

@@ -17,6 +17,14 @@ module Syntropy
       @opts = opts
     end
 
+    # Logs an DEBUG entry.
+    #
+    # @param o [Hash] log entry
+    # @return [void]
+    def debug(o)
+      call(:DEBUG, o)
+    end
+
     # Logs an INFO entry.
     #
     # @param o [Hash] log entry

data/lib/syntropy/markdown.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'yaml'
+require 'securerandom'
 
 module Syntropy
   # Markdown parsing.
@@ -11,30 +12,153 @@ module Syntropy
       symbolize_names: true
     }.freeze
 
+    # Implements a Markdown file controller.
+    class Controller
+      def initialize(env, atts, md)
+        @env = env
+        @atts = atts
+        @md = md
+        @module_loader = env[:module_loader]
+      end
+
+      # Returns the controller proc.
+      #
+      # @return [Proc] controller proc
+      def to_proc
+        ->(req) {
+          case req.method
+          when 'head'
+            req.respond_html(nil)
+          when 'get'
+            md = process_md_embeds
+            html = render(md)
+            req.respond_html(html)
+          else
+            req.respond(nil, ':status' => HTTP::METHOD_NOT_ALLOWED)
+          end
+        }
+      end
+
+      private
+
+      # Process any Papercraft embeds in the markdown file by rendering them
+      # into the markdown code.
+      #
+      # @return [String] Markdown with rendered embeds
+      def process_md_embeds
+        return @md if @embedded_templates&.empty?
+
+        @embedded_templates = {}
+        @md.gsub(/^```ruby\n# render: true\n(.*?)\r?\n```\n/m) {
+          snippet = Regexp.last_match[1]
+          templ = @embedded_templates[snippet] ||= prepare_snippet_template(snippet)
+          Papercraft.html(templ)
+        }
+      end
+
+      # Prepares a snippet template by writing it to a temporary file and
+      # instance_eval'ing the code, returning a Papercraft template.
+      #
+      # @param snippet [String] Papercraft snippet
+      # @param _location [String] currently not used
+      # @return [Proc] Papercraft template
+      def prepare_snippet_template(snippet, _location = nil)
+        fn = "/tmp/snippet-#{SecureRandom.hex(8)}.rb"
+        src = "->() do\n#{snippet}\nend"
+        IO.write(fn, src)
+        instance_eval src, fn
+      end
+
+      # Renders the given markdown to HTML.
+      #
+      # @param md [String] markdown
+      # @return [String] HTML
+      def render(md)
+        @template ||= make_template
+        Papercraft.html(@template, md: md, **@atts)
+      end
+
+      # Makes a Markdown rendering template based on the corresponding layout.
+      #
+      # @return [Proc] Papercraft template
+      def make_template
+        layout = make_layout
+        Papercraft.apply(layout) { |md:, **| markdown(md) }
+      end
+
+      # Makes a layout template by loading the layout module. If no layout
+      # module was specified, returns the default layout.
+      #
+      # @return [Proc] Layout template
+      def make_layout
+        return default_layout if !@atts[:layout]
+        raise Error, 'Missing module loader' if !@module_loader
+
+        @module_loader.load("_layout/#{@atts[:layout]}")
+      end
+
+      # Creates a default layout template.
+      #
+      # @return [Proc] Default layout template
+      def default_layout
+        ->(**atts) {
+          html5 {
+            head {
+              title atts[:title] if atts[:title]
+            }
+            body {
+              render_children(**atts)
+              auto_refresh!
+            }
+          }
+        }
+      end
+    end
+
     class << self
       # Parses the markdown file at the given path.
       #
       # @param path [String] file path
       # @return [Array] an tuple containing properties<Hash>, contents<String>
-      def parse(path, env)
-        content = IO.read(path) || ''
+      def parse_file(path, env)
+        md = IO.read(path) || ''
         atts = {}
-
-        parse_date(path, atts)
-        content = parse_content(content, atts)
         atts[:url] = path_to_url(path, env[:app_root]) if env[:app_root]
+        parse_date(atts, path)
+
+        parse_md(atts, md)
+      end
 
-        [atts, content]
+      # Parses the markdown content, returning the attributes and cleaned up
+      # markdown.
+      #
+      # @param atts [Hash] attributes hash
+      # @param md [String] markdown file
+      # @return [Array<atts, md>] Array containing attributes and clean markdown
+      def parse_md(atts, md)
+        md = parse_content(atts, md)
+        [atts, md]
+      end
+
+      # Creates a Markdown file contoroller for the given environment,
+      # attributes and markdown.
+      #
+      # @param env [Hash]  app environment
+      # @param atts [Hash] markdown file attributes
+      # @param md [String] markdown
+      # @return [Markdown::Controller] controller instance
+      def make_controller(env, atts, md)
+        Controller.new(env, atts, md).to_proc
       end
 
       private
 
       # Parses date information from the given path.
       #
-      # @param path [String] file path
       # @param atts [Hash] file attributes
+      # @param path [String] file path
       # @return [void]
-      def parse_date(path, atts)
+      def parse_date(atts, path)
         # Parse date from file name
         if (m = path.match(/(\d{4}-\d{2}-\d{2})/))
           atts[:date] ||= Date.parse(m[1])
@@ -43,10 +167,10 @@ module Syntropy
 
       # Parses the markdown content and front matter attributes from the given content.
       #
-      # @param content [String] file content
       # @param atts [Hash] file attributes
+      # @param content [String] file content
       # @return [String] parsed markdown content
-      def parse_content(content, atts)
+      def parse_content(atts, content)
         if (m = content.match(FRONT_MATTER_REGEXP))
           front_matter = m[1]
           content = m.post_match
@@ -63,7 +187,11 @@ module Syntropy
       # @param app_root [String] app root directory
       # @return [String] url
       def path_to_url(path, app_root)
-        path.gsub(/#{app_root}/, '').gsub(/\.md$/, '')
+        if app_root == '/'
+          path.gsub(/\.md$/, '')
+        else
+          path.gsub(/#{app_root}/, '').gsub(/\.md$/, '')
+        end
       end
     end
   end

data/lib/syntropy/module_loader.rb

@@ -21,7 +21,7 @@ module Syntropy
   # reference `_lib/foo` will point to a module residing in
   # `/my_site/_lib/foo.rb`.
   class ModuleLoader
-    attr_reader :modules
+    attr_reader :modules, :app_root
 
     # Instantiates a module loader
     #
@@ -30,25 +30,31 @@ module Syntropy
     # @return [void]
     def initialize(env, extensions: nil)
       @env = env
+      @machine = env[:machine]
       @app_root = env[:app_root]
       @modules = {} # maps ref to module entry
       @fn_map = {} # maps filename to ref
       @extensions = extensions
+      @loading = Set.new
+      @lock = UM::Mutex.new
+      @lock_holder = nil
     end
 
     # Loads a module (if not already loaded) and returns its export value.
     #
     # @param ref [String] module reference
     # @return [any] export value
-    def load(ref, raise_on_missing: true)
-      ref = "/#{ref}" if ref !~ /^\//
-      if !(entry = @modules[ref])
-        entry = load_module(ref, raise_on_missing:)
-        return if !entry
-
-        @modules[ref] = entry
+    def load(ref, raise_on_missing_export: true)
+      lock do
+        ref = "/#{ref}" if ref !~ /^\//
+        if !(entry = @modules[ref])
+          entry = load_module(ref, raise_on_missing_export:)
+          return if !entry
+
+          @modules[ref] = entry
+        end
+        entry[:export_value]
       end
-      entry[:export_value]
     end
 
     # Returns a list of modules found in the given relative path. The module
@@ -70,13 +76,29 @@ module Syntropy
     # @param fn [String] module filename
     # @return [void]
     def invalidate_fn(fn)
-      ref = @fn_map[fn]
-      invalidate_ref(ref) if ref
-      invalidate_collection_modules
+      lock do
+        ref = @fn_map[fn]
+        invalidate_ref(ref) if ref
+        invalidate_collection_modules
+      end
     end
 
     private
 
+    # Synchronizes access to the module loader state
+    #
+    # @return [any] block return value
+    def lock
+      return yield if @lock_holder == Fiber.current
+
+      @machine.synchronize(@lock) do
+        @lock_holder = Fiber.current
+        yield
+      ensure
+        @lock_holder = nil
+      end
+    end
+
     # Invalidates a module by its reference, normally following a change to the
     # underlying file (in order to cause reloading of the module). The module
     # will be removed from the modules map, as well as modules dependending on
@@ -122,23 +144,35 @@ module Syntropy
     #
     # @param ref [String] module reference
     # @return [Hash] module entry
-    def load_module(ref, raise_on_missing: true)
+    def load_module(ref, raise_on_missing_export: true)
       ref = "/#{ref}" if ref !~ /^\//
       fn = File.expand_path(File.join(@app_root, "#{ref}.rb"))
       if !File.file?(fn)
-        raise Syntropy::Error, "File not found #{fn}" if raise_on_missing
+        raise Syntropy::Error, "File not found #{fn}" if raise_on_missing_export
 
         return
       end
 
+      raise Syntropy::Error, "Circular dependency detected" if @loading.include?(ref)
+      do_load_module(ref, fn, raise_on_missing_export:)
+    end
+
+    # Loads a module.
+    #
+    # @param ref [String] module reference
+    # @param fn [String] module filename
+    # @param raise_on_missing_export [bool] whether to raise on missing export
+    def do_load_module(ref, fn, raise_on_missing_export:)
+      @loading << ref
       @fn_map[fn] = ref
-      code = IO.read(fn)
+      code = read_file(fn)
       env = @env.merge(module_loader: self, ref: clean_ref(ref))
-      mod = Syntropy::ModuleContext.load(env, code, fn, @extensions)
+      mod = Syntropy::ModuleContext.new(env, code, fn, @extensions)
       add_dependencies(ref, mod.__dependencies__)
       export_value = transform_module_export_value(
-        mod.__export_value__, fn, raise_on_missing:
+        mod, fn, raise_on_missing_export:
       )
+      @env[:logger]&.info(message: "Loaded module at #{fn}")
 
       {
         fn: fn,
@@ -146,6 +180,23 @@ module Syntropy
         export_value: export_value,
         reverse_deps: []
       }
+    rescue StandardError, SyntaxError => e
+      env[:logger]&.error(message: "Error while loading module at #{fn}", error: e)
+      e.is_a?(SyntaxError) ? handle_syntax_error(fn, e) : (raise e)
+    ensure
+      @loading.delete(ref)
+    end
+
+    # Returns a file's content.
+    #
+    # @param fn [String] filename
+    # @return [String] file content
+    def read_file(fn)
+      @machine.open(fn, UM::O_RDONLY) { |fd|
+        buf = +''
+        res = @machine.read(fd, buf, 1 << 20)
+        buf
+      }
     end
 
     # Cleans up a module reference specifier, turning /index into /
@@ -159,21 +210,34 @@ module Syntropy
       (clean == '') ? '/' : clean
     end
 
-    # Transforms the given export value. If the value is nil, an exception is
-    # raised.
+    # Transforms the given module's export value. If the value is nil, an
+    # exception is raised.
     #
-    # @param export_value [any] module's export value
+    # @param mod [Syntropy::ModuleContext] module context
     # @return [any] transformed value
-    def transform_module_export_value(export_value, fn, raise_on_missing:)
-      case export_value
+    def transform_module_export_value(mod, fn, raise_on_missing_export:)
+      case (value = mod.__export_value__)
       when nil
-        raise Syntropy::Error, "No export found in #{fn}" if raise_on_missing
+        mod
       when String
-        ->(req) { req.respond(export_value) }
+        ->(req) { req.respond(value) }
       else
-        export_value
+        value
       end
     end
+
+    # Handles a syntax error encountered while loading a module by generating a
+    # new exception with a backtrace including the syntax error location.
+    def handle_syntax_error(fn, e)
+      $stderr.puts("\n#{e.message}") if !Syntropy.test_mode
+      m = e.message.match(/^(.+): syntax/)
+      raise e if !m
+
+      location = m[1]
+      e2 = SyntaxError.new("Syntax errors found in module at #{fn}")
+      e2.set_backtrace([location] + e.backtrace)
+      raise e2
+    end
   end
 
   # The Syntropy::ModuleContext class provides a context for loading a module. A
@@ -193,44 +257,14 @@ module Syntropy
   # is set to `self`, and may be used to refer to various methods defined in the
   # module.
   class ModuleContext
-    # Loads a module, returning the module instance
-    # @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}")
-      mod
-    rescue StandardError, SyntaxError => e
-      env[:logger]&.error(message: "Error while loading module at #{fn}", error: e)
-      e.is_a?(SyntaxError) ? handle_syntax_error(env, e) : (raise e)
-    end
-
-    # 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 Syntropy::Error, "Invalid module extensions: #{extensions.inspect}"
-      end
-    end
-
     # Initializes a module with the given environment hash.
     #
     # @param env [Hash] environment hash
+    # @param code [String] module source code
+    # @param fn [String] module filename
+    # @param extensions [Array<Module>, Module]
     # @return [void]
-    def initialize(env)
+    def initialize(env, code, fn, extensions)
       @env = env
       @machine = env[:machine]
       @module_loader = env[:module_loader]
@@ -239,6 +273,9 @@ module Syntropy
       @logger = env[:logger]
       @__dependencies__ = []
       singleton_class.const_set(:MODULE, self)
+
+      apply_extensions(extensions)
+      instance_eval(code, fn)
     end
 
     attr_reader :__export_value__, :__dependencies__
@@ -334,15 +371,20 @@ module Syntropy
       Syntropy::App.new(**env)
     end
 
-    def handle_syntax_error(env, e)
-      $stderr.puts("\n#{e.message}") if !Syntropy.test_mode
-      m = e.message.match(/^(.+): syntax/)
-      raise e if !m
-
-      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 extensions [Module, Array<Module>] extension module(s)
+    # @return [void]
+    def apply_extensions(extensions)
+      case extensions
+      when Array
+        extensions.each { extend(it) }
+      when Module
+        extend(extensions)
+      when nil # return
+      else
+        raise Syntropy::Error, "Invalid module extensions: #{extensions.inspect}"
+      end
     end
   end
 end

data/lib/syntropy/request/request_info.rb

@@ -228,6 +228,14 @@ module Syntropy
       nil
     end
 
+    # Expands a relative path based on the request's path.
+    #
+    # param rel_path [String]
+    # @return [String]
+    def rel(rel_path)
+      File.expand_path(File.join(path, rel_path))
+    end
+
     private
 
     # Parses an accept string into an array of accepted MIME types.