syntropy 0.3 → 0.5

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'
@@ -10,39 +12,50 @@ require 'syntropy/module'
 
 module Syntropy
   class App
-    attr_reader :route_cache
+    class << self
+      def load(opts)
+        site_file_app(opts) || default_app(opts)
+      end
+
+      private
+
+      def site_file_app(opts)
+        site_fn = File.join(opts[:location], '_site.rb')
+        return nil if !File.file?(site_fn)
+
+        loader = Syntropy::ModuleLoader.new(opts[:location], opts)
+        loader.load('_site')
+      end
+
+      def default_app(opts)
+        new(opts[:machine], opts[:location], opts[:mount_path] || '/', opts)
+      end
+    end
 
     def initialize(machine, src_path, mount_path, opts = {})
       @machine = machine
       @src_path = File.expand_path(src_path)
       @mount_path = mount_path
-      @route_cache = {}
       @opts = opts
 
-      @relative_path_re = calculate_relative_path_re(mount_path)
+      @module_loader = Syntropy::ModuleLoader.new(@src_path, @opts)
+      @router = Syntropy::Router.new(@opts, @module_loader)
+
       @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]
+        @router.start_file_watcher if opts[:watch_files]
       end
     end
 
-    def find_route(path, cache: true)
-      cached = @route_cache[path]
-      return cached if cached
-
-      entry = calculate_route(path)
-      if entry[:kind] != :not_found
-        @route_cache[path] = entry if cache
-      end
-      entry
-    end
-
     def call(req)
-      entry = find_route(req.path)
+      entry = @router[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
@@ -51,132 +64,59 @@ module Syntropy
 
     private
 
-    def start_file_watcher
-      @opts[:logger]&.call('Watching for module file changes...', nil)
-      wf = @opts[:watch_files]
-      period = wf.is_a?(Numeric) ? wf : 0.1
-      @machine.spin do
-        Syntropy.file_watch(@machine, @src_path, period: period) do
-          @opts[:logger]&.call("Detected changed file: #{it}")
-          invalidate_cache(it)
-        rescue Exception => e
-          p e
-          p e.backtrace
-          exit!
-        end
-      end
-    end
-
-    def invalidate_cache(fn)
-      invalidated_keys = []
-      @route_cache.each do |k, v|
-        @opts[:logger]&.call("Invalidate cache for #{k}", nil)
-        invalidated_keys << k if v[:fn] == fn
-      end
-
-      invalidated_keys.each { @route_cache.delete(it) }
-    end
-
-    def calculate_relative_path_re(mount_path)
-      mount_path = '' if mount_path == '/'
-      /^#{mount_path}(?:\/(.*))?$/
-    end
-
-    FILE_KINDS = {
-      '.rb' => :module,
-      '.md' => :markdown
-    }
-    NOT_FOUND = { kind: :not_found }
-
-    # We don't allow access to path with /.., or entries that start with _
-    FORBIDDEN_RE = /(\/_)|((\/\.\.)\/?)/
-
-    def calculate_route(path)
-      return NOT_FOUND if path =~ FORBIDDEN_RE
-
-      m = path.match(@relative_path_re)
-      return NOT_FOUND if !m
-
-      relative_path = m[1] || ''
-      fs_path = File.join(@src_path, relative_path)
-
-      return file_entry(fs_path) if File.file?(fs_path)
-      return find_index_entry(fs_path) if File.directory?(fs_path)
-
-      entry = find_file_entry_with_extension(fs_path)
-      return entry if entry[:kind] != :not_found
-
-      find_up_tree_module(path)
-    end
-
-    def file_entry(fn)
-      { fn: File.expand_path(fn), kind: FILE_KINDS[File.extname(fn)] || :static }
-    end
-
-    def find_index_entry(dir)
-      find_file_entry_with_extension(File.join(dir, 'index'))
-    end
-
-    def find_file_entry_with_extension(path)
-      fn = "#{path}.html"
-      return file_entry(fn) if File.file?(fn)
-
-      fn = "#{path}.md"
-      return file_entry(fn) if File.file?(fn)
-
-      fn = "#{path}.rb"
-      return file_entry(fn) if File.file?(fn)
-
-      fn = "#{path}+.rb"
-      return file_entry(fn) if File.file?(fn)
-
-      NOT_FOUND
-    end
-
-    def find_up_tree_module(path)
-      parent = parent_path(path)
-      return NOT_FOUND if !parent
-
-      entry = find_route("#{parent}+.rb", cache: false)
-      entry[:kind] == :module ? entry : NOT_FOUND
-    end
-
-    UP_TREE_PATH_RE = /^(.+)?\/[^\/]+$/
-
-    def parent_path(path)
-      m = path.match(UP_TREE_PATH_RE)
-      m && m[1]
-    end
-
     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)
-      entry[:code] ||= load_module(entry)
-      if entry[:code] == :invalid
+    def respond_module(req, entry)
+      entry[:proc] ||= load_module(entry)
+      if entry[:proc] == :invalid
         req.respond(nil, ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
         return
       end
 
-      entry[:code].call(req)
+      entry[:proc].call(req)
+    rescue Syntropy::Error => e
+      req.respond(nil, ':status' => e.http_status)
     rescue StandardError => e
       p e
       p e.backtrace
@@ -184,24 +124,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/file_watch.rb

@@ -8,15 +8,16 @@ module Syntropy
 
     queue = Thread::Queue.new
     listener = Listen.to(*roots) do |modified, added, removed|
-      fns = (modified + added + removed).uniq
-      fns.each { queue.push(it) }
+      modified.each { queue.push([:modified, it]) }
+      added.each    { queue.push([:added, it]) }
+      removed.each  { queue.push([:removed, it]) }
     end
     listener.start
 
     loop do
       machine.sleep(period) while queue.empty?
-      fn = queue.shift
-      block.call(fn)
+      event, fn = queue.shift
+      block.call(event, fn)
     end
   rescue StandardError => e
     p e

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 invalidate(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)