syntropy 0.3 → 0.4

data/lib/syntropy/app.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-require 'qeweney'
 require 'json'
+require 'yaml'
+
+require 'qeweney'
 require 'papercraft'
 
 require 'syntropy/errors'
@@ -23,10 +25,12 @@ module Syntropy
       @machine.spin do
         # we do startup stuff asynchronously, in order to first let TP2 do its
         # setup tasks
-        @machine.sleep 0.25
+        @machine.sleep 0.15
         @opts[:logger]&.call("Serving from #{File.expand_path(@src_path)}")
         start_file_watcher if opts[:watch_files]
       end
+
+      @module_loader ||= Syntropy::ModuleLoader.new(@src_path, @opts)
     end
 
     def find_route(path, cache: true)
@@ -34,15 +38,16 @@ module Syntropy
       return cached if cached
 
       entry = calculate_route(path)
-      if entry[:kind] != :not_found
-        @route_cache[path] = entry if cache
-      end
+      @route_cache[path] = entry if entry[:kind] != :not_found && cache
       entry
     end
 
     def call(req)
       entry = find_route(req.path)
       render_entry(req, entry)
+    rescue Syntropy::Error => e
+      msg = e.message
+      req.respond(msg.empty? ? nil : msg, ':status' => e.http_status)
     rescue StandardError => e
       p e
       p e.backtrace
@@ -68,6 +73,8 @@ module Syntropy
     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)
@@ -79,7 +86,7 @@ module Syntropy
 
     def calculate_relative_path_re(mount_path)
       mount_path = '' if mount_path == '/'
-      /^#{mount_path}(?:\/(.*))?$/
+      %r{^#{mount_path}(?:/(.*))?$}
     end
 
     FILE_KINDS = {
@@ -89,7 +96,7 @@ module Syntropy
     NOT_FOUND = { kind: :not_found }
 
     # We don't allow access to path with /.., or entries that start with _
-    FORBIDDEN_RE = /(\/_)|((\/\.\.)\/?)/
+    FORBIDDEN_RE = %r{(/_)|((/\.\.)/?)}
 
     def calculate_route(path)
       return NOT_FOUND if path =~ FORBIDDEN_RE
@@ -141,7 +148,7 @@ module Syntropy
       entry[:kind] == :module ? entry : NOT_FOUND
     end
 
-    UP_TREE_PATH_RE = /^(.+)?\/[^\/]+$/
+    UP_TREE_PATH_RE = %r{^(.+)?/[^/]+$}
 
     def parent_path(path)
       m = path.match(UP_TREE_PATH_RE)
@@ -151,25 +158,47 @@ module Syntropy
     def render_entry(req, entry)
       case entry[:kind]
       when :not_found
-        req.respond('Not found', ':status' => Qeweney::Status::NOT_FOUND)
+        respond_not_found(req, entry)
       when :static
         respond_static(req, entry)
       when :markdown
-        body = render_markdown(IO.read(entry[:fn]))
-        req.respond(body, 'Content-Type' => 'text/html')
+        respond_markdown(req, entry)
       when :module
-        call_module(req, entry)
+        respond_module(req, entry)
       else
         raise 'Invalid entry kind'
       end
     end
 
+    def respond_not_found(req, _entry)
+      headers = { ':status' => Qeweney::Status::NOT_FOUND }
+      case req.method
+      when 'head'
+        req.respond(nil, headers)
+      else
+        req.respond('Not found', headers)
+      end
+    end
+
     def respond_static(req, entry)
       entry[:mime_type] ||= Qeweney::MimeTypes[File.extname(entry[:fn])]
-      req.respond(IO.read(entry[:fn]), 'Content-Type' => entry[:mime_type])
+      headers = { 'Content-Type' => entry[:mime_type] }
+      req.respond_by_http_method(
+        'head'  => [nil, headers],
+        'get'   => -> { [IO.read(entry[:fn]), headers] }
+      )
+    end
+
+    def respond_markdown(req, entry)
+      entry[:mime_type] ||= Qeweney::MimeTypes[File.extname(entry[:fn])]
+      headers = { 'Content-Type' => entry[:mime_type] }
+      req.respond_by_http_method(
+        'head'  => [nil, headers],
+        'get'   => -> { [render_markdown(entry[:fn]), headers] }
+      )
     end
 
-    def call_module(req, entry)
+    def respond_module(req, entry)
       entry[:code] ||= load_module(entry)
       if entry[:code] == :invalid
         req.respond(nil, ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
@@ -177,6 +206,8 @@ module Syntropy
       end
 
       entry[:code].call(req)
+    rescue Syntropy::Error => e
+      req.respond(nil, ':status' => e.http_status)
     rescue StandardError => e
       p e
       p e.backtrace
@@ -184,24 +215,62 @@ module Syntropy
     end
 
     def load_module(entry)
-      loader = Syntropy::ModuleLoader.new(@src_path, @opts)
-      ref = entry[:fn].gsub(%r{^#{@src_path}\/}, '').gsub(/\.rb$/, '')
-      o = loader.load(ref)
-      # klass = Class.new
-      # o = klass.instance_eval(body, entry[:fn], 1)
-
-      o.is_a?(Papercraft::HTML) ? wrap_template(o) : o
+      ref = entry[:fn].gsub(%r{^#{@src_path}/}, '').gsub(/\.rb$/, '')
+      o = @module_loader.load(ref)
+      o.is_a?(Papercraft::Template) ? wrap_template(o) : o
+    rescue Exception => e
+      @opts[:logger]&.call("Error while loading module #{ref}: #{e.message}")
+      :invalid
     end
 
     def wrap_template(templ)
-      ->(req) {
+      lambda { |req|
         body = templ.render
         req.respond(body, 'Content-Type' => 'text/html')
       }
     end
 
-    def render_markdown(str)
-      Papercraft.markdown(str)
+    def render_markdown(fn)
+      atts, md = parse_markdown_file(fn)
+
+      if atts[:layout]
+        layout = @module_loader.load("_layout/#{atts[:layout]}")
+        html = layout.apply { emit_markdown(md) }.render
+      else
+        html = Papercraft.markdown(md)
+      end
+      html
+    end
+
+    DATE_REGEXP = /(\d{4}\-\d{2}\-\d{2})/
+    FRONT_MATTER_REGEXP = /\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)/m
+    YAML_OPTS = {
+      permitted_classes: [Date],
+      symbolize_names: true
+    }
+
+    # Parses the markdown file at the given path.
+    #
+    # @param path [String] file path
+    # @return [Array] an tuple containing properties<Hash>, contents<String>
+    def parse_markdown_file(path)
+      content = IO.read(path) || ''
+      atts = {}
+
+      # Parse date from file name
+      if (m = path.match(DATE_REGEXP))
+        atts[:date] ||= Date.parse(m[1])
+      end
+
+      if (m = content.match(FRONT_MATTER_REGEXP))
+        front_matter = m[1]
+        content = m.post_match
+
+        yaml = YAML.safe_load(front_matter, **YAML_OPTS)
+        atts = atts.merge(yaml)
+      end
+
+      [atts, content]
     end
   end
 end

data/lib/syntropy/errors.rb

@@ -4,17 +4,31 @@ require 'qeweney'
 
 module Syntropy
   class Error < StandardError
+    Status = Qeweney::Status
+
     attr_reader :http_status
 
     def initialize(status, msg = '')
-      @http_status = status || Qeweney::Status::INTERNAL_SERVER_ERROR
       super(msg)
+      @http_status = status || Qeweney::Status::INTERNAL_SERVER_ERROR
+    end
+
+    class << self
+      # Create class methods for common errors
+      {
+        not_found:          Status::NOT_FOUND,
+        method_not_allowed: Status::METHOD_NOT_ALLOWED,
+        teapot:             Status::TEAPOT
+      }
+      .each { |k, v|
+        define_method(k) { |msg = ''| new(v, msg) }
+      }
     end
   end
 
   class ValidationError < Error
     def initialize(msg)
-      @http_status = Qeweney::Status::BAD_REQUEST
+      super(Qeweney::Status::BAD_REQUEST, msg)
     end
   end
 end

data/lib/syntropy/module.rb

@@ -1,37 +1,54 @@
 # frozen_string_literal: true
 
+require 'papercraft'
+
 module Syntropy
   class ModuleLoader
     def initialize(root, env)
       @root = root
       @env = env
-      @loaded = {}
+      @loaded = {} # maps ref to code
+      @fn_map = {} # maps filename to ref
     end
 
     def load(ref)
       @loaded[ref] ||= load_module(ref)
     end
 
+    def unload(fn)
+      ref = @fn_map[fn]
+      return if !ref
+
+      @loaded.delete(ref)
+      @fn_map.delete(fn)
+    end
+
     private
 
     def load_module(ref)
-      fn = File.join(@root, "#{ref}.rb")
-      raise RuntimeError, "File not found #{fn}" if !File.file?(fn)
+      fn = File.expand_path(File.join(@root, "#{ref}.rb"))
+      @fn_map[fn] = ref
+      raise "File not found #{fn}" if !File.file?(fn)
 
       mod_body = IO.read(fn)
       mod_ctx = Class.new(Syntropy::Module)
       mod_ctx.loader = self
-      # mod_ctx = .new(self, @env)
       mod_ctx.module_eval(mod_body, fn, 1)
 
       export_value = mod_ctx.__export_value__
 
+      wrap_module(mod_ctx, export_value)
+    end
+
+    def wrap_module(mod_ctx, export_value)
       case export_value
       when nil
-        raise RuntimeError, 'No export found'
+        raise 'No export found'
       when Symbol
         # TODO: verify export_value denotes a valid method
         mod_ctx.new(@env)
+      when String
+        ->(req) { req.respond(export_value) }
       when Proc
         export_value
       else
@@ -57,6 +74,10 @@ module Syntropy
       @__export_value__ = ref
     end
 
+    def self.templ(&block)
+      Papercraft.html(&block)
+    end
+
     def self.__export_value__
       @__export_value__
     end

data/lib/syntropy/request_extensions.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'qeweney'
+
+module Syntropy
+  module RequestExtensions
+    def ctx
+      @ctx ||= {}
+    end
+
+    def validate_http_method(*accepted)
+      raise Syntropy::Error.method_not_allowed if !accepted.include?(method)
+    end
+
+    def respond_by_http_method(map)
+      value = map[self.method]
+      raise Syntropy::Error.method_not_allowed if !value
+
+      value = value.() if value.is_a?(Proc)
+      (body, headers) = value
+      respond(body, headers)
+    end
+
+    def respond_on_get(body, headers = {})
+      case self.method
+      when 'head'
+        respond(nil, headers)
+      when 'get'
+        respond(body, headers)
+      else
+      raise Syntropy::Error.method_not_allowed
+      end
+    end
+
+    def respond_on_post(body, headers = {})
+      case self.method
+      when 'head'
+        respond(nil, headers)
+      when 'post'
+        respond(body, headers)
+      else
+      raise Syntropy::Error.method_not_allowed
+      end
+    end
+
+    def validate_param(name, *clauses)
+      value = query[name]
+      clauses.each do |c|
+        valid = param_is_valid?(value, c)
+        raise(Syntropy::ValidationError, 'Validation error') if !valid
+
+        value = param_convert(value, c)
+      end
+      value
+    end
+
+    private
+
+    BOOL_REGEXP = /^(t|f|true|false|on|off|1|0|yes|no)$/
+    BOOL_TRUE_REGEXP = /^(t|true|on|1|yes)$/
+    INTEGER_REGEXP = /^[+-]?[0-9]+$/
+    FLOAT_REGEXP = /^[+-]?[0-9]+(\.[0-9]+)?$/
+
+    def param_is_valid?(value, cond)
+      return cond.any? { |c| param_is_valid?(value, c) } if cond.is_a?(Array)
+
+      if value
+        if cond == :bool
+          return value =~ BOOL_REGEXP
+        elsif cond == Integer
+          return value =~ INTEGER_REGEXP
+        elsif cond == Float
+          return value =~ FLOAT_REGEXP
+        end
+      end
+
+      cond === value
+    end
+
+    def param_convert(value, klass)
+      if klass == :bool
+        value =~ BOOL_TRUE_REGEXP ? true : false
+      elsif klass == Integer
+        value.to_i
+      elsif klass == Float
+        value.to_f
+      elsif klass == Symbol
+        value.to_sym
+      else
+        value
+      end
+    end
+  end
+end
+
+Qeweney::Request.include(Syntropy::RequestExtensions)

data/lib/syntropy/rpc_api.rb

@@ -11,7 +11,7 @@ module Syntropy
     end
 
     def call(req)
-      response, status = invoke(req)
+      response, status = __invoke__(req)
       req.respond(
         response.to_json,
         ':status'       => status,
@@ -19,15 +19,17 @@ module Syntropy
       )
     end
 
-    def invoke(req)
-      q = req.validate_param(:q, String)
+    private
+
+    def __invoke__(req)
+      q = req.validate_param(:q, String).to_sym
       response = case req.method
       when 'get'
-        send(q.to_sym, req)
+        __invoke_get__(q, req)
       when 'post'
-        send(:"#{q}!", req)
+        __invoke_post__(q, req)
       else
-        raise Syntropy::Error.new(Qeweney::Status::METHOD_NOT_ALLOWED)
+        raise Syntropy::Error.method_not_allowed
       end
       [{ status: 'OK', response: response }, Qeweney::Status::OK]
     rescue => e
@@ -35,14 +37,29 @@ module Syntropy
         p e
         p e.backtrace
       end
-      error_response(e)
+      __error_response__(e)
+    end
+
+    def __invoke_get__(sym,  req)
+      return send(sym, req) if respond_to?(sym)
+
+      err = respond_to?(:"#{sym}!") ? Syntropy::Error.method_not_allowed : Syntropy::Error.not_found
+      raise err
+    end
+
+    def __invoke_post__(sym, req)
+      sym_post = :"#{sym}!"
+      return send(sym_post, req) if respond_to?(sym_post)
+
+      err = respond_to?(sym) ? Syntropy::Error.method_not_allowed : Syntropy::Error.not_found
+      raise err
     end
 
     INTERNAL_SERVER_ERROR = Qeweney::Status::INTERNAL_SERVER_ERROR
 
-    def error_response(err)
+    def __error_response__(err)
       http_status = err.respond_to?(:http_status) ? err.http_status : INTERNAL_SERVER_ERROR
-      error_name = err.class.name
+      error_name = err.class.name.split('::').last
       [{ status: error_name, message: err.message }, http_status]
     end
   end

data/lib/syntropy/side_run.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'etc'
+
+module Syntropy
+  module SideRun
+    class << self
+      def call(machine, &block)
+        setup if !@queue
+
+        # TODO: share mailboxes, acquire them with e.g. with_mailbox { |mbox| ... }
+        mailbox = Thread.current[:fiber_mailbox] ||= UM::Queue.new
+        machine.push(@queue, [mailbox, block])
+        result = machine.shift(mailbox)
+        result.is_a?(Exception) ? (raise result) : result
+      end
+
+      def setup
+        @queue = UM::Queue.new
+        count = (Etc.nprocessors - 1).clamp(2..6)
+        @workers = count.times.map {
+          Thread.new { side_run_worker(@queue) }
+        }
+      end
+
+      def side_run_worker(queue)
+        machine = UM.new
+        loop { handle_request(machine, queue) }
+      rescue UM::Terminate
+        # # We can also add a timeout here
+        # t0 = Time.now
+        # while !queue.empty? && (Time.now - t0) < 10
+        #   handle_request(machine, queue)
+        # end
+      end
+
+      def handle_request(machine, queue)
+        response_mailbox, closure = machine.shift(queue)
+        result = closure.call
+        machine.push(response_mailbox, result)
+      rescue Exception => e
+        machine.push(response_mailbox, e)
+      end
+    end
+  end
+end

data/lib/syntropy/version.rb

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

data/lib/syntropy.rb

@@ -8,64 +8,29 @@ require 'syntropy/errors'
 require 'syntropy/connection_pool'
 require 'syntropy/module'
 require 'syntropy/rpc_api'
+require 'syntropy/side_run'
 require 'syntropy/app'
+require 'syntropy/request_extensions'
 
-class Qeweney::Request
-  def ctx
-    @ctx ||= {}
-  end
-
-  def validate_param(name, *clauses)
-    value = query[name]
-    clauses.each do |c|
-      valid = param_is_valid?(value, c)
-      raise(Syntropy::ValidationError, 'Validation error') if !valid
-      value = param_convert(value, c)
-    end
-    value
-  end
-
-  private
-
-  BOOL_REGEXP = /^(t|f|true|false|on|off|1|0|yes|no)$/
-  BOOL_TRUE_REGEXP = /^(t|true|on|1|yes)$/
-  INTEGER_REGEXP = /^[\+\-]?[0-9]+$/
-  FLOAT_REGEXP = /^[\+\-]?[0-9]+(\.[0-9]+)?$/
+module Syntropy
+    Status = Qeweney::Status
 
-  def param_is_valid?(value, cond)
-    if cond == :bool
-      return (value && value =~ BOOL_REGEXP)
-    elsif cond == Integer
-      return (value && value =~ INTEGER_REGEXP)
-    elsif cond == Float
-      return (value && value =~ FLOAT_REGEXP)
-    elsif cond.is_a?(Array)
-      return cond.any? { |c| param_is_valid?(value, c) }
-    end
+  class << self
+    attr_accessor :machine
 
-    cond === value
-  end
+    def side_run(&block)
+      raise 'Syntropy.machine not set' if !@machine
 
-  def param_convert(value, klass)
-    if klass == :bool
-      value = value =~ BOOL_TRUE_REGEXP ? true : false
-    elsif klass == Integer
-      value = value.to_i
-    elsif klass == Float
-      value = value.to_f
-    else
-      value
+      SideRun.call(@machine, &block)
     end
   end
-end
 
-module Syntropy
   def colorize(color_code)
     "\e[#{color_code}m#{self}\e[0m"
   end
 
   GREEN = "\e[32m"
-  WHITE = "\e[0m"
+  CLEAR = "\e[0m"
   YELLOW = "\e[33m"
 
   BANNER = (
@@ -73,10 +38,10 @@ module Syntropy
     "  #{GREEN}\n"\
     "  #{GREEN} ooo\n"\
     "  #{GREEN}ooooo\n"\
-    "  #{GREEN} ooo vvv       #{WHITE}Syntropy - a web framework for Ruby\n"\
-    "  #{GREEN}  o vvvvv     #{WHITE}--------------------------------------\n"\
-    "  #{GREEN}  #{YELLOW}|#{GREEN}  vvv o    #{WHITE}https://github.com/noteflakes/syntropy\n"\
+    "  #{GREEN} ooo vvv       #{CLEAR}Syntropy - a web framework for Ruby\n"\
+    "  #{GREEN}  o vvvvv     #{CLEAR}--------------------------------------\n"\
+    "  #{GREEN}  #{YELLOW}|#{GREEN}  vvv o    #{CLEAR}https://github.com/noteflakes/syntropy\n"\
     "  #{GREEN} :#{YELLOW}|#{GREEN}:::#{YELLOW}|#{GREEN}::#{YELLOW}|#{GREEN}:\n"\
-    "  #{YELLOW}++++++++++++\e[0m\n\n"
+    "#{YELLOW}+++++++++++++++++++++++++++++++++++++++++++++++++++++++++\e[0m\n\n"
   )
 end

data/syntropy.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'json',          '2.12.2'
   s.add_dependency 'papercraft',    '1.4'
   s.add_dependency 'qeweney',       '0.21'
-  s.add_dependency 'tp2',           '0.12.3.1'
+  s.add_dependency 'tp2',           '0.13.2'
   s.add_dependency 'uringmachine',  '0.15'
 
   s.add_dependency 'listen',        '3.9.0'

data/test/app/baz.rb

@@ -0,0 +1,3 @@
+export ->(req) {
+  req.respond_on_get('foobar')
+}