syntropy 0.3 → 0.5

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/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.5'
 end

data/lib/syntropy.rb

@@ -8,64 +8,30 @@ require 'syntropy/errors'
 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'
 
-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 +39,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')
+}

data/test/app_custom/_site.rb

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

data/test/test_app.rb

@@ -2,57 +2,23 @@
 
 require_relative 'helper'
 
-class AppRoutingTest < Minitest::Test
+class AppTest < Minitest::Test
+  Status = Qeweney::Status
+
   APP_ROOT = File.join(__dir__, 'app')
 
   def setup
     @machine = UM.new
 
     @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]
+    @tmp_fn = File.join(APP_ROOT, 'tmp.rb')
+
+    @app = Syntropy::App.load(
+      machine: @machine,
+      location: APP_ROOT,
+      mount_path: '/test',
+      watch_files: 0.05
+    )
   end
 
   def make_request(*, **)
@@ -63,39 +29,91 @@ class AppRoutingTest < Minitest::Test
 
   def test_app_rendering
     req = make_request(':method' => 'GET', ':path' => '/')
-    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+    assert_equal 'Not found', req.response_body
+    assert_equal Status::NOT_FOUND, req.response_status
+
+    req = make_request(':method' => 'HEAD', ':path' => '/')
+    assert_nil req.response_body
+    assert_equal Status::NOT_FOUND, req.response_status
+
+    req = make_request(':method' => 'POST', ':path' => '/')
+    assert_equal 'Not found', req.response_body
+    assert_equal Status::NOT_FOUND, req.response_status
 
     req = make_request(':method' => 'GET', ':path' => '/test')
-    assert_equal Qeweney::Status::OK, req.response_status
+    assert_equal Status::OK, req.response_status
     assert_equal '<h1>Hello, world!</h1>', req.response_body
 
+    req = make_request(':method' => 'HEAD', ':path' => '/test')
+    assert_equal Status::OK, req.response_status
+    assert_nil req.response_body
+
+    req = make_request(':method' => 'POST', ':path' => '/test')
+    assert_equal Status::METHOD_NOT_ALLOWED, req.response_status
+    assert_nil req.response_body
+
     req = make_request(':method' => 'GET', ':path' => '/test/index')
     assert_equal '<h1>Hello, world!</h1>', req.response_body
 
     req = make_request(':method' => 'GET', ':path' => '/test/index.html')
     assert_equal '<h1>Hello, world!</h1>', req.response_body
+    assert_equal 'text/html', req.response_headers['Content-Type']
+
+    req = make_request(':method' => 'HEAD', ':path' => '/test/index.html')
+    assert_nil req.response_body
+    assert_equal 'text/html', req.response_headers['Content-Type']
+
+    req = make_request(':method' => 'POST', ':path' => '/test/index.html')
+    assert_nil req.response_body
+    assert_equal Status::METHOD_NOT_ALLOWED, req.response_status
 
     req = make_request(':method' => 'GET', ':path' => '/test/assets/style.css')
     assert_equal '* { color: beige }', req.response_body
+    assert_equal 'text/css', req.response_headers['Content-Type']
 
     req = make_request(':method' => 'GET', ':path' => '/assets/style.css')
-    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+    assert_equal Status::NOT_FOUND, req.response_status
 
     req = make_request(':method' => 'GET', ':path' => '/test/api?q=get')
     assert_equal({ status: 'OK', response: 0 }, req.response_json)
 
+    req = make_request(':method' => 'POST', ':path' => '/test/api?q=get')
+    assert_equal Status::METHOD_NOT_ALLOWED, req.response_status
+    assert_equal({ status: 'Error', message: '' }, req.response_json)
+
     req = make_request(':method' => 'GET', ':path' => '/test/api/foo?q=get')
     assert_equal({ status: 'OK', response: 0 }, req.response_json)
 
     req = make_request(':method' => 'POST', ':path' => '/test/api?q=incr')
     assert_equal({ status: 'OK', response: 1 }, req.response_json)
 
+    req = make_request(':method' => 'GET', ':path' => '/test/api?q=incr')
+    assert_equal Status::METHOD_NOT_ALLOWED, req.response_status
+    assert_equal({ status: 'Error', message: '' }, req.response_json)
+
     req = make_request(':method' => 'POST', ':path' => '/test/api/foo?q=incr')
-    assert_equal({ status: 'Syntropy::Error', message: 'Teapot' }, req.response_json)
-    assert_equal Qeweney::Status::TEAPOT, req.response_status
+    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
+
+    req = make_request(':method' => 'POST', ':path' => '/test/bar')
+    assert_equal 'foobar', req.response_body
+    assert_equal Status::OK, req.response_status
+
+    req = make_request(':method' => 'GET', ':path' => '/test/baz')
+    assert_equal 'foobar', req.response_body
+    assert_equal Status::OK, req.response_status
+
+    req = make_request(':method' => 'POST', ':path' => '/test/baz')
+    assert_nil req.response_body
+    assert_equal Status::METHOD_NOT_ALLOWED, req.response_status
 
     req = make_request(':method' => 'GET', ':path' => '/test/about')
     assert_equal 'About', req.response_body.chomp
@@ -104,7 +122,7 @@ class AppRoutingTest < Minitest::Test
     assert_equal '<p>Hello from Markdown</p>', req.response_body.chomp
 
     req = make_request(':method' => 'GET', ':path' => '/test/about/foo/bar')
-    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+    assert_equal Status::NOT_FOUND, req.response_status
   end
 
   def test_app_file_watching
@@ -123,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)