syntropy 0.10.1 → 0.12

data/lib/syntropy/router.rb

@@ -1,245 +0,0 @@
-# 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]&.info(
-        message: 'Watching for file changes...'
-      )
-      @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 == '/'
-
-      m = path.match(PATH_PARENT_RE)
-      m && (m[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]&.info(
-        message: "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/test/test_router.rb

@@ -1,116 +0,0 @@
-# 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_routing
-    # 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/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
-
-  def test_malformed_path_routing
-    entry = @router['//xmlrpc.php?rsd']
-    assert_equal :not_found, entry[:kind]
-
-    entry = @router['/test//xmlrpc.php?rsd']
-    assert_equal :not_found, entry[:kind]
-
-    entry = @router['/test///xmlrpc.php?rsd']
-    assert_equal :not_found, entry[:kind]
-
-    entry = @router['/test///xmlrpc.php?rsd']
-    assert_equal :not_found, entry[:kind]
-
-    entry = @router['/test/./qsdf']
-    assert_equal :not_found, entry[:kind]
-
-    entry = @router['/test/../../lib/syntropy.rb']
-    assert_equal :not_found, entry[:kind]
-
-    entry = @router['/../../lib/syntropy.rb']
-    assert_equal :not_found, entry[:kind]
-  end
-end

data/test/test_validation.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class ValidationTest < Minitest::Test
-  def setup
-    @req = mock_req(':method' => 'GET', ':path' => '/foo?q=foo&x=bar&y=123&z1=t&z2=f')
-  end
-
-  VE = Syntropy::ValidationError
-
-  def test_validate_param
-    assert_nil @req.validate_param(:azerty, nil)
-    assert_equal 'foo', @req.validate_param(:q)
-    assert_equal 'foo', @req.validate_param(:q, String)
-    assert_equal 'foo', @req.validate_param(:q, [String, nil])
-    assert_nil @req.validate_param(:r, [String, nil])
-
-    assert_equal 123, @req.validate_param(:y, Integer)
-    assert_equal 123, @req.validate_param(:y, Integer, 120..125)
-    assert_equal 123.0, @req.validate_param(:y, Float)
-
-    assert_equal true, @req.validate_param(:z1, :bool)
-    assert_equal false, @req.validate_param(:z2, :bool)
-
-    assert_raises(VE) { @req.validate_param(:azerty, String) }
-    assert_raises(VE) { @req.validate_param(:q, Integer) }
-    assert_raises(VE) { @req.validate_param(:q, Float) }
-    assert_raises(VE) { @req.validate_param(:q, nil) }
-
-    assert_raises(VE) { @req.validate_param(:y, Integer, 1..100) }
-
-    assert_raises(VE) { @req.validate_param(:y, :bool) }
-  end
-end