impression 0.2 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aaea11fcf3fcaab1902290a620d9cdb0fa5dfb11ae38c90335f80471629d652f
-  data.tar.gz: 9eaebd5c2a28856a568e583399c3ea6db8332e6c2aae6d570639505788203dc1
+  metadata.gz: 5644ebb122c166a8a5579a950b3e64fde5d3d332eea8299aa4c4023af8b85cb6
+  data.tar.gz: b89065d1cd8c14d5ddad28f1fc3ff90cc48d43354698e339715f3b6d172af671
 SHA512:
-  metadata.gz: 145722a3828e039ed1a021c002cc0a551e66f78a300d869203f15d8c3df8c2d532d71d37674a7c11b1d995c39cb138a06040665a785e22581473843d28581a49
-  data.tar.gz: 9d179f895f2d819f1c63762099137dda5511614176c9e25df4aef7d735975fbda25167b5f3c3a94788f96c8b37ece7c2f42acc7b54dcaa38054863976f039ccf
+  metadata.gz: 45ab7c1f4e3c9f920175acc8bce2417932571ceca8946cf1fd0b784a6280413514587bc998d467808023c56e054a0edc2c821e6dc700289a4a02f4e2372dfe05
+  data.tar.gz: d3b57e4089e0473e508f5a67c52db12be7a62850897bc79a27871b4ea7a3d2b3b3062f214980a98d5e842033b62496ae9024416c37b00ca05b527b01c088b53e

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.3 2022-01-19
+
+- Implement basic Jamstack resource (#5)
+- Add support for stock callable responses (#4)
+- Make resource callable, rename `#respond` to `#callable` (#3)
+
 ## 0.2 2022-01-13
 
 - Implement `FileTree` (#2)

data/Gemfile

@@ -2,7 +2,7 @@ source 'https://rubygems.org'
 
 gemspec
 
-# %w{polyphony tipi qeweney rubyoshka}.each do |dep|
+# %w{polyphony tipi qeweney papercraft}.each do |dep|
 #   dir = "../#{dep}"
 #   gem(dep, path: dir) if File.directory?(dir)
 # end

data/Gemfile.lock

@@ -1,10 +1,11 @@
 PATH
   remote: .
   specs:
-    impression (0.2)
+    impression (0.3)
       kramdown (~> 2.3.0)
       kramdown-parser-gfm (~> 1.1.0)
-      papercraft (~> 0.12)
+      modulation (~> 1.1)
+      papercraft (~> 0.14)
       polyphony (~> 0.73.1)
       qeweney (~> 0.15)
       rouge (~> 3.26.0)
@@ -51,9 +52,10 @@ GEM
       kramdown (~> 2.0)
     localhost (1.1.9)
     minitest (5.11.3)
+    modulation (1.1)
     msgpack (1.4.2)
     multipart-post (2.1.1)
-    papercraft (0.12)
+    papercraft (0.14)
       escape_utils (= 1.2.1)
       kramdown (~> 2.3.0)
       kramdown-parser-gfm (~> 1.1.0)

data/README.md

@@ -1,2 +1,44 @@
-# impression
-A modern web framework for Ruby
+<h1 align="center">
+  Impression
+</h1>
+
+<h4 align="center">A modern web framework for Ruby</h4>
+
+<p align="center">
+  <a href="http://rubygems.org/gems/impression">
+    <img src="https://badge.fury.io/rb/impression.svg" alt="Ruby gem">
+  </a>
+  <a href="https://github.com/digital-fabric/impression/actions?query=workflow%3ATests">
+    <img src="https://github.com/digital-fabric/impression/workflows/Tests/badge.svg" alt="Tests">
+  </a>
+  <a href="https://github.com/digital-fabric/impression/blob/master/LICENSE">
+    <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT License">
+  </a>
+</p>
+
+## What is Impression
+
+> Impression is still in a very early stage of development. Things might not
+> correctly, or not at all.
+
+Impression is a modern web framework for Ruby. Unlike other web framework,
+Impression does not impose any rigid structure or paradigm, but instead provides
+a set of tools letting you build any kind of web app, by freely mixing different
+kinds of web resources, be they static files, structured templates, Jamstack
+sites, or dynamic APIs.
+
+In Impression, resources can be composed into a hierarchical tree, allowing
+combining of multiple web apps, or web subsystems, into a single URL hierarchy.
+
+Impression is made for running on top of
+[Tipi](https://github.com/digital-fabric/tipi), a new all-in-one web server for
+Ruby.
+
+## I want to know more
+
+Further documentation is coming real soon (TM)...
+
+## Contributing
+
+Contributions in the form of issues, PRs or comments will be greatly
+appreciated!

data/impression.gemspec

@@ -28,7 +28,8 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency      'kramdown-parser-gfm',  '~>1.1.0'
 
   # s.add_runtime_dependency      'rb-inotify',           '~>0.10.1'
-  s.add_runtime_dependency      'papercraft',            '~>0.12'
+  s.add_runtime_dependency      'papercraft',            '~>0.14'
+  s.add_runtime_dependency      'modulation',           '~>1.1'
 
   
   s.add_development_dependency  'rake',                 '~>12.3.3'

data/lib/impression/file_tree.rb

@@ -22,9 +22,9 @@ module Impression
     #
     # @param req [Qeweney::Request] request
     # @return [void]
-    def respond(req)
+    def call(req)
       path_info = get_path_info(req.resource_relative_path)
-      render_from_path_info(req, *path_info)
+      render_from_path_info(req, path_info)
     end
 
     private
@@ -34,56 +34,91 @@ module Impression
     # @param req [Qeweney::Request] request
     # @param kind [Symbol] path kind (`:not_found` or `:file`)
     # @param path [String, nil] file path
-    def render_from_path_info(req, kind, path = nil)
-      case kind
+    def render_from_path_info(req, path_info)
+      case path_info[:kind]
       when :not_found
         req.respond(nil, ':status' => Qeweney::Status::NOT_FOUND)
       when :file
-        req.serve_file(path)
+        render_file(req, path_info)
       else
         raise "Invalid path info kind #{kind.inspect}"
       end
     end
 
+    private
+
+    # Renders a file response for the given request and the given path info.
+    #
+    # @param req [Qeweney::Request] request
+    # @param path_info [Hash] path info
+    # @return [void]
+    def render_file(req, path_info)
+      req.serve_file(path_info[:path])
+    end
+
     # Returns the path info for the given relative path.
     #
     # @param path [String] relative path
-    # @return [Array] path info (a tuple comprising kind and file path)
+    # @return [Hash] path info
     def get_path_info(path)
-      @path_info_cache[path] || calculate_path_info(path)
+      @path_info_cache[path] ||= calculate_path_info(path)
     end
 
     # Calculates the path info for the given relative path.
     #
     # @param path [String] relative path
-    # @param add_html_ext [bool] whether to add .html extension if not found
-    # @return [Array] path info
-    def calculate_path_info(path, add_html_ext = true)
+    # @param add_ext [bool] whether to add .html extension if not found
+    # @return [Hash] path info
+    def calculate_path_info(path)
       full_path = File.join(@directory, path)
 
-      stat = File.stat(full_path) rescue nil
+      path_info(full_path) || search_path_info_with_extension(full_path) || { kind: :not_found }
+    end
+
+    # Returns the path info for the given path. If the path refers to a file,
+    # returns a hash containing the file information. If the path refers to a
+    # directory, performs a search for an index file using #directory_path_info.
+    # Otherwise, returns nil.
+    #
+    # @param path [String] path
+    # @return [Hash, nil] path info
+    def path_info(path)
+      stat = File.stat(path) rescue nil
       if !stat
-        return add_html_ext ?
-          calculate_path_info("#{path}.html", false) : [:not_found]
+        nil
       elsif stat.directory?
-        return calculate_directory_path_info(full_path)
+        return directory_path_info(path)
       else
-        return [:file, full_path]
+        return { kind: :file, path: path, ext: File.extname(path) }
       end
     end
 
-    # Calculates the path info for a directory. If an `index.html` file exists,
-    # its path info is returned, otherwise a `:not_found` path info is returned.
+    # Calculates the path info for a directory. If an index file exists, its
+    # path info is returned, otherwise, returns nil.
     #
     # @param path [String] directory path
-    # @return [Array] path info
-    def calculate_directory_path_info(path)
-      index_path = File.join(path, 'index.html')
-      if File.file?(index_path)
-        [:file, index_path]
-      else
-        [:not_found]
+    # @return [Hash, nil] path info
+    def directory_path_info(path)
+      search_path_info_with_extension(File.join(path, 'index'))
+    end
+
+    # Returns the supported path extensions for paths without extension.
+    #
+    # @return [Array] supported extensions
+    def supported_path_extensions
+      [:html]
+    end
+
+    # Searches for files with extensions for the given path.
+    #
+    # @param path [String] path
+    # @return [Hash, nil] path info
+    def search_path_info_with_extension(path)
+      supported_path_extensions.each do |ext|
+        info = path_info("#{path}.#{ext}")
+        return info if info
       end
+      nil
     end
   end
 end

data/lib/impression/jamstack.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+require 'modulation'
+require 'papercraft'
+
+require_relative './resource'
+require_relative './file_tree'
+
+module Impression
+
+  # `Jamstack` implements a resource that maps to a Jamstack app directory.
+  class Jamstack < FileTree
+    def initialize(**props)
+      super
+      @layouts = {}
+    end
+
+    private
+
+    # Renders a file response for the given request and the given path info.
+    #
+    # @param req [Qeweney::Request] request
+    # @param path_info [Hash] path info
+    # @return [void]
+    def render_file(req, path_info)
+      case path_info[:ext]
+      when '.rb'
+        render_papercraft_module(req, path_info[:path])
+      when '.md'
+        render_markdown_file(req, path_info[:path])
+      else
+        req.serve_file(path_info[:path])
+      end
+    end
+
+    # Renders a Papercraft module. The module is loaded using Modulation.
+    #
+    # @param req [Qeweney::Request] reqest
+    # @param path [String] file path
+    # @return [void]
+    def render_papercraft_module(req, path)
+      mod = import path
+
+      html = H(mod).render
+      req.respond(html, 'Content-Type' => Qeweney::MimeTypes[:html])
+    end
+
+    # Renders a markdown file using a layout.
+    #
+    # @param req [Qeweney::Request] reqest
+    # @param path [String] file path
+    # @return [void]
+    def render_markdown_file(req, path)
+      attributes, markdown = parse_markdown_file(path)
+
+      layout = get_layout(attributes[:layout])
+
+      html = layout.render(**attributes) { emit_markdown markdown }
+      req.respond(html, 'Content-Type' => Qeweney::MimeTypes[:html])
+    end
+
+    # Returns a layout component based on the given name. The given name
+    # defaults to 'default' if nil.
+    #
+    # @param layout [String, nil] layout name
+    # @return [Papercraft::Component] layout component
+    def get_layout(layout)
+      layout ||= 'default'
+      path = File.join(@directory, "_layouts/#{layout}.rb")
+      raise "Layout not found #{path}" unless File.file?(path)
+      
+      import path
+    end
+
+    MARKDOWN_PAGE_REGEXP = /\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)/m.freeze
+  
+    # 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)
+      data = IO.read(path) || ''
+      if (m = data.match(MARKDOWN_PAGE_REGEXP))
+        front_matter = m[1]
+
+        [symbolize_keys(YAML.load(front_matter)), m.post_match]
+      else
+        [{}, data]
+      end
+    end
+
+    # Converts a hash with string keys to one with symbol keys.
+    #
+    # @param hash [Hash] input hash
+    # @return [Hash] output hash
+    def symbolize_keys(hash)
+      hash.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+    end
+
+    # Returns the supported path extensions used for searching for files based
+    # on pretty URLs.
+    #
+    # @return [Array] list of supported path extensions
+    def supported_path_extensions
+      [:html, :rb, :md]
+    end
+  end
+end

data/lib/impression/request_extensions/responses.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Impression
+  
+  module RequestExtensions
+
+    # Response extensions for `Qeweney::Request`
+    module Responses
+
+      TEXT_HEADERS = { 'Content-Type' => Qeweney::MimeTypes[:txt] }.freeze
+      HTML_HEADERS = { 'Content-Type' => Qeweney::MimeTypes[:html] }.freeze
+      JSON_HEADERS = { 'Content-Type' => Qeweney::MimeTypes[:json] }.freeze
+
+      # Send an HTTP response with plain text content. The content type is set
+      # to `text/plain`.
+      #
+      # @param text [String] response body
+      # @param **headers [Hash] additional response headers
+      def respond_text(text, **headers)
+        headers = headers.empty? ? TEXT_HEADERS : headers.merge(TEXT_HEADERS)
+        respond(text, headers)
+      end
+
+      # Send an HTTP response with HTML content. The content type is set to
+      # `text/html`.
+      #
+      # @param html [String] response body
+      # @param **headers [Hash] additional response headers
+      def respond_html(html, **headers)
+        headers = headers.empty? ? HTML_HEADERS : headers.merge(HTML_HEADERS)
+        respond(html, headers)
+      end
+
+      # Send an JSON response. The given object is converted to JSON. The
+      # content type is set to `application/json`.
+      #
+      # @param object [any] object to convert to JSON
+      # @param **headers [Hash] additional response headers
+      def respond_json(object, **headers)
+        headers = headers.empty? ? JSON_HEADERS : headers.merge(JSON_HEADERS)
+        respond(object.to_json, headers)
+      end
+    end
+
+  end
+end

data/lib/impression/request_extensions/routing.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Impression
+  
+  # Extensions for `Qeweney::Request`
+  module RequestExtensions
+
+    # Routing extensions for `Qeweney::Request`
+    module Routing
+
+      # Matches a route regexp against the relative request path. The relative
+      # request path is a separate string (stored in `@resource_relative_path`)
+      # that is updated as routes are matched against it. The `route_regexp`
+      # should be either `nil` for root routes (`/`) or a Regexp of the form
+      # `/^#{route}(\/.*)?$/`. See also `Resource#initialize`.
+      #
+      # @param route_regexp [Regexp, nil] Route regexp to match against
+      # @return [String, nil] The remainder of the path (relative to the route)
+      def match_resource_path?(route_regexp)
+        @resource_relative_path ||= path.dup
+
+        return @resource_relative_path unless route_regexp
+
+        # Simplified logic: no match returns nil, otherwise we set the relative path for 
+        @resource_relative_path = match_resource_relative_path(
+          @resource_relative_path, route_regexp
+        )
+      end
+
+      # Returns the relative_path for the latest matched resource
+      #
+      # @return [String]
+      def resource_relative_path
+        @resource_relative_path ||= path.dup
+      end
+
+      private
+
+      # Matches the given path against the given route regexp. If the path matches
+      # the regexp, the relative path for the given route is returned. Otherwise,
+      # this method returns `nil`.
+      #
+      # @param path [String] path to match
+      # @param route_regexp [Regexp] route regexp to match against
+      # @return [String, nil] the relative path for the given route, or nil if no match.
+      def match_resource_relative_path(path, route_regexp)
+        match = path.match(route_regexp)
+        match && (match[1] || '/')
+      end
+    end
+  end
+end

data/lib/impression/request_extensions.rb

@@ -3,11 +3,13 @@
 require 'qeweney'
 
 # require_relative './pages'
-require_relative './request_routing'
+require_relative './request_extensions/routing'
+require_relative './request_extensions/responses'
 
 # Extensions to `Qeweney::Request`
 class Qeweney::Request
   
   # include Impression::Pages::RequestMethods
-  include Impression::RequestRouting
+  include Impression::RequestExtensions::Routing
+  include Impression::RequestExtensions::Responses
 end

data/lib/impression/resource.rb

@@ -71,7 +71,7 @@ module Impression
     #
     # @param req [Qeweney::Request] request
     # @return [void]
-    def respond(req)
+    def call(req)
       req.respond(nil, ':status' => Qeweney::Status::NOT_FOUND)
     end
 
@@ -122,10 +122,37 @@ module Impression
     def to_proc
       ->(req) do
         resource = route(req) || self
-        resource.respond(req)
+        resource.call(req)
       end
     end
 
+    # Returns a callable that responds with plain text using the given
+    # parameters.
+    #
+    # @param text [String] response body
+    # @param **headers [Hash] additional response headers
+    def text_response(text, **headers)
+      ->(req) { req.respond_text(text, **headers) }
+    end
+
+    # Returns a callable that responds with HTML using the given
+    # parameters.
+    #
+    # @param html [String] response body
+    # @param **headers [Hash] additional response headers
+    def html_response(html, **headers)
+      ->(req) { req.respond_html(html, **headers) }
+    end
+
+    # Returns a callable that responds with JSON using the given
+    # parameters.
+    #
+    # @param object [any] object to be converted to JSON
+    # @param **headers [Hash] additional response headers
+    def json_response(object, **headers)
+      ->(req) { req.respond_json(object, **headers) }
+    end
+
     private
 
     SLASH_PREFIXED_PATH_REGEXP = /^\//.freeze

data/lib/impression/version.rb

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

data/lib/impression.rb

@@ -7,4 +7,5 @@ require_relative './impression/request_extensions'
 
 require_relative './impression/resource'
 require_relative './impression/file_tree'
+require_relative './impression/jamstack'
 require_relative './impression/app'

data/test/helper.rb

@@ -41,33 +41,33 @@ module Minitest::Assertions
   end
 
   def assert_response exp_body, exp_content_type, req
-    msg = message(msg) { "Expected response body #{mu_pp(act)} to equal #{mu_pp(exp_body)}" }
-    assert_equal exp_body, req.response_body, msg
+    actual = req.response_body
+    assert_equal exp_body.gsub("\n", ''), actual&.gsub("\n", '')
 
     return unless exp_content_type
 
     if Symbol === exp_content_type
       exp_content_type = Qeweney::MimeTypes[exp_content_type]
     end
-    msg = message(msg) { "Expected response content type #{mu_pp(act)} to equal #{mu_pp(exp_body)}" }
-    assert_equal exp_content_type, req.response_content_type, msg
+    actual = req.response_content_type
+    assert_equal exp_content_type, actual
   end
 end
 
 class Impression::Resource
-  def route_and_respond(req)
-    route(req).respond(req)
+  def route_and_call(req)
+    route(req).call(req)
   end
 end
 
 class PathRenderingResource < Impression::Resource
-  def respond(req)
+  def call(req)
     req.respond(absolute_path)
   end
 end
 
 class CompletePathInfoRenderingResource < Impression::Resource
-  def respond(req)
+  def call(req)
     req.respond("#{absolute_path} #{req.resource_relative_path}")
   end
 end

data/test/jamstack/_layouts/article.rb

@@ -0,0 +1,9 @@
+require 'papercraft'
+
+default = import('./default')
+
+export_default default.apply { |**props|
+  article {
+    emit_yield
+  }
+}

data/test/jamstack/_layouts/default.rb

@@ -0,0 +1,12 @@
+require 'papercraft'
+
+export_default H { |**props|
+  html5 {
+    head {
+      title props[:title]
+    }
+    body {
+      emit_yield **props
+    }
+  }
+}

data/test/jamstack/articles/a.md

@@ -0,0 +1,6 @@
+---
+title: AAA
+layout: article
+---
+
+## BBB

data/test/jamstack/assets/js/a.js

@@ -0,0 +1 @@
+console.log(42);

data/test/jamstack/bar.html

@@ -0,0 +1 @@
+<h1>Bar</h1>

data/test/jamstack/baz/index.md

@@ -0,0 +1,7 @@
+---
+title: BarBar
+---
+
+<h1>BarIndex</h1>
+
+

data/test/jamstack/foo.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+layout = import('./_layouts/default')
+
+export_default layout.apply(title: 'Foo title') {
+  h1 'foo'
+}

data/test/jamstack/index.md

@@ -0,0 +1,4 @@
+---
+title: Hello
+---
+<h1>Index</h1>

data/test/test_app.rb

@@ -7,7 +7,7 @@ class AppTest < MiniTest::Test
     app = Impression::App.new(path: '/')
     req = mock_req(':method' => 'GET', ':path' => '/')
 
-    app.respond(req)
+    app.call(req)
     assert_equal Qeweney::Status::NOT_FOUND, req.adapter.status
   end
 

data/test/test_file_tree.rb

@@ -30,43 +30,43 @@ class FileTreeTest < MiniTest::Test
 
   def test_file_tree_response
     req = mock_req(':method' => 'GET', ':path' => '/roo')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_equal Qeweney::Status::NOT_FOUND, req.response_status
 
     req = mock_req(':method' => 'GET', ':path' => '/foo2')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_equal Qeweney::Status::NOT_FOUND, req.response_status
 
     req = mock_req(':method' => 'GET', ':path' => '/bar2')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_equal Qeweney::Status::NOT_FOUND, req.response_status
 
     req = mock_req(':method' => 'GET', ':path' => '/js/a.js')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('js/a.js'), :js, req
 
     req = mock_req(':method' => 'GET', ':path' => '/foo.html')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('foo.html'), :html, req
 
     req = mock_req(':method' => 'GET', ':path' => '/foo')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('foo.html'), :html, req
 
     req = mock_req(':method' => 'GET', ':path' => '/index.html')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('index.html'), :html, req
 
     req = mock_req(':method' => 'GET', ':path' => '/')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('index.html'), :html, req
 
     req = mock_req(':method' => 'GET', ':path' => '/bar/index.html')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('bar/index.html'), :html, req
 
     req = mock_req(':method' => 'GET', ':path' => '/bar')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('bar/index.html'), :html, req
   end
 
@@ -74,43 +74,43 @@ class FileTreeTest < MiniTest::Test
     @file_tree = Impression::FileTree.new(path: '/app', directory: STATIC_PATH)
 
     req = mock_req(':method' => 'GET', ':path' => '/app/roo')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_equal Qeweney::Status::NOT_FOUND, req.response_status
 
     req = mock_req(':method' => 'GET', ':path' => '/app/foo2')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_equal Qeweney::Status::NOT_FOUND, req.response_status
 
     req = mock_req(':method' => 'GET', ':path' => '/app/bar2')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_equal Qeweney::Status::NOT_FOUND, req.response_status
 
     req = mock_req(':method' => 'GET', ':path' => '/app/js/a.js')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('js/a.js'), :js, req
 
     req = mock_req(':method' => 'GET', ':path' => '/app/foo.html')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('foo.html'), :html, req
 
     req = mock_req(':method' => 'GET', ':path' => '/app/foo')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('foo.html'), :html, req
 
     req = mock_req(':method' => 'GET', ':path' => '/app/index.html')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('index.html'), :html, req
 
     req = mock_req(':method' => 'GET', ':path' => '/app/')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('index.html'), :html, req
 
     req = mock_req(':method' => 'GET', ':path' => '/app/bar/index.html')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('bar/index.html'), :html, req
 
     req = mock_req(':method' => 'GET', ':path' => '/app/bar')
-    @file_tree.route_and_respond(req)
+    @file_tree.route_and_call(req)
     assert_response static('bar/index.html'), :html, req
   end
 end

data/test/test_jamstack.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'qeweney/test_adapter'
+
+class JamstackTest < MiniTest::Test
+  JAMSTACK_PATH = File.join(__dir__, 'jamstack')
+
+  def setup
+    @jamstack = Impression::Jamstack.new(path: '/', directory: JAMSTACK_PATH)
+  end
+
+  def test_jamstack_routing
+    req = mock_req(':method' => 'GET', ':path' => '/')
+    assert_equal @jamstack, @jamstack.route(req)
+
+    req = mock_req(':method' => 'GET', ':path' => '/nonexistent')
+    assert_equal @jamstack, @jamstack.route(req)
+
+    req = mock_req(':method' => 'GET', ':path' => '/index.html')
+    assert_equal @jamstack, @jamstack.route(req)
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo')
+    assert_equal @jamstack, @jamstack.route(req)
+  end
+
+  def static(path)
+    IO.read(File.join(JAMSTACK_PATH, path))
+  end
+
+  def test_jamstack_response
+    req = mock_req(':method' => 'GET', ':path' => '/roo')
+    @jamstack.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo2')
+    @jamstack.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/bar2')
+    @jamstack.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/assets/js/a.js')
+    @jamstack.route_and_call(req)
+    assert_response static('assets/js/a.js'), :js, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo')
+    @jamstack.route_and_call(req)
+
+    foo = H {
+      html5 {
+        head {
+          title 'Foo title'
+        }
+        body {
+          h1 'foo'
+        }
+      }
+    }
+    assert_response foo.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/index')
+    @jamstack.route_and_call(req)
+
+    index = H {
+      html5 {
+        head {
+          title 'Hello'
+        }
+        body {
+          h1 'Index'
+        }
+      }
+    }
+    assert_response index.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/')
+    @jamstack.route_and_call(req)
+    assert_response index.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/bar')
+    @jamstack.route_and_call(req)
+    assert_response static('bar.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/baz')
+    @jamstack.route_and_call(req)
+
+    baz_index = H {
+      html5 {
+        head {
+          title 'BarBar'
+        }
+        body {
+          h1 'BarIndex'
+        }
+      }
+    }
+    assert_response baz_index.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/articles/a')
+    @jamstack.route_and_call(req)
+
+    a = H {
+      html5 {
+        head {
+          title 'AAA'
+        }
+        body {
+          article {
+            h2 'BBB', id: 'bbb'
+          }
+        }
+      }
+    }
+    assert_response a.render, :html, req
+  end
+
+  def test_non_root_file_tree_response
+    @jamstack = Impression::Jamstack.new(path: '/app', directory: JAMSTACK_PATH)
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/roo')
+    @jamstack.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/foo2')
+    @jamstack.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/bar2')
+    @jamstack.route_and_call(req)
+    assert_equal Qeweney::Status::NOT_FOUND, req.response_status
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/assets/js/a.js')
+    @jamstack.route_and_call(req)
+    assert_response static('assets/js/a.js'), :js, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/foo')
+    @jamstack.route_and_call(req)
+
+    foo = H {
+      html5 {
+        head {
+          title 'Foo title'
+        }
+        body {
+          h1 'foo'
+        }
+      }
+    }
+    assert_response foo.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/index')
+    @jamstack.route_and_call(req)
+
+    index = H {
+      html5 {
+        head {
+          title 'Hello'
+        }
+        body {
+          h1 'Index'
+        }
+      }
+    }
+    assert_response index.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/')
+    @jamstack.route_and_call(req)
+    assert_response index.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/bar')
+    @jamstack.route_and_call(req)
+    assert_response static('bar.html'), :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/baz')
+    @jamstack.route_and_call(req)
+
+    baz_index = H {
+      html5 {
+        head {
+          title 'BarBar'
+        }
+        body {
+          h1 'BarIndex'
+        }
+      }
+    }
+    assert_response baz_index.render, :html, req
+
+    req = mock_req(':method' => 'GET', ':path' => '/app/articles/a')
+    @jamstack.route_and_call(req)
+
+    a = H {
+      html5 {
+        head {
+          title 'AAA'
+        }
+        body {
+          article {
+            h2 'BBB', id: 'bbb'
+          }
+        }
+      }
+    }
+    assert_response a.render, :html, req
+  end
+end

data/test/test_resource.rb

@@ -78,16 +78,16 @@ class ResourceTest < MiniTest::Test
     assert_nil r1.route(req)
 
     req = mock_req(':method' => 'GET', ':path' => '/foo')
-    r1.route(req).respond(req)
+    r1.route_and_call(req)
     # default reply
     assert_equal Qeweney::Status::NOT_FOUND, req.response_status
 
     req = mock_req(':method' => 'GET', ':path' => '/foo/bar')
-    r1.route(req).respond(req)
+    r1.route_and_call(req)
     assert_equal '/foo/bar', req.response_body
 
     req = mock_req(':method' => 'GET', ':path' => '/foo/baz')
-    r1.route(req).respond(req)
+    r1.route_and_call(req)
     assert_equal '/foo/baz', req.response_body
 
     req = mock_req(':method' => 'GET', ':path' => '/foo/bbb')
@@ -103,27 +103,99 @@ class ResourceTest < MiniTest::Test
     assert_nil r1.route(req)
 
     req = mock_req(':method' => 'GET', ':path' => '/foo')
-    r1.route(req).respond(req)
+    r1.route_and_call(req)
     assert_equal '/foo /', req.response_body
 
     req = mock_req(':method' => 'GET', ':path' => '/foo/zzz')
-    r1.route(req).respond(req)
+    r1.route_and_call(req)
     assert_equal '/foo /zzz', req.response_body
 
     req = mock_req(':method' => 'GET', ':path' => '/foo/bar')
-    r1.route(req).respond(req)
+    r1.route_and_call(req)
     assert_equal '/foo/bar /', req.response_body
 
     req = mock_req(':method' => 'GET', ':path' => '/foo/bar/zzz')
-    r1.route(req).respond(req)
+    r1.route_and_call(req)
     assert_equal '/foo/bar /zzz', req.response_body
 
     req = mock_req(':method' => 'GET', ':path' => '/foo/baz')
-    r1.route(req).respond(req)
+    r1.route_and_call(req)
     assert_equal '/foo/baz /', req.response_body
 
     req = mock_req(':method' => 'GET', ':path' => '/foo/baz/xxx/yyy')
-    r1.route(req).respond(req)
+    r1.route_and_call(req)
     assert_equal '/foo/baz /xxx/yyy', req.response_body
   end
+
+  class CallableResource < Impression::Resource
+    def initialize(**props, &block)
+      super(**props)
+      @block = block
+    end
+
+    def call(req)
+      @block.call(req)
+    end
+  end
+
+  def test_callable_resource
+    r1 = CompletePathInfoRenderingResource.new(path: 'foo')
+    r2 = CallableResource.new(parent: r1, path: 'bar') { |req| req.respond('hi') }
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/bar')
+    r1.route_and_call(req)
+    assert_equal 'hi', req.response_body
+  end
+
+  class CallableRouteResource < Impression::Resource
+    def initialize(**props, &block)
+      super(**props)
+      @block = block
+    end
+
+    def route(req)
+      @block
+    end
+  end
+
+  def test_callable_from_route_method
+    r1 = CompletePathInfoRenderingResource.new(path: 'foo')
+    r2 = CallableRouteResource.new(parent: r1, path: 'bar') { |req| req.respond('bye') }
+
+    req = mock_req(':method' => 'GET', ':path' => '/foo/bar')
+    r1.route_and_call(req)
+    assert_equal 'bye', req.response_body
+  end
+
+  def test_text_response
+    c = Class.new(Impression::Resource) do
+      def route(req)
+        case req.path
+        when '/text'
+          text_response('foo')
+        when '/html'
+          html_response('bar')
+        when '/json'
+          json_response({ :baz => 123 })
+        end
+      end
+    end
+
+    r = c.new(path: '/')
+
+    req = mock_req(':method' => 'GET', ':path' => '/text')
+    r.route_and_call(req)
+    assert_equal 'foo', req.response_body
+    assert_equal 'text/plain', req.response_content_type
+
+    req = mock_req(':method' => 'GET', ':path' => '/html')
+    r.route_and_call(req)
+    assert_equal 'bar', req.response_body
+    assert_equal 'text/html', req.response_content_type
+
+    req = mock_req(':method' => 'GET', ':path' => '/json')
+    r.route_and_call(req)
+    assert_equal '{"baz":123}', req.response_body
+    assert_equal 'application/json', req.response_content_type
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: impression
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.3'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-13 00:00:00.000000000 Z
+date: 2022-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: polyphony
@@ -100,14 +100,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: '0.14'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: modulation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -177,12 +191,22 @@ files:
 - lib/impression/errors.rb
 - lib/impression/file_tree.rb
 - lib/impression/file_watcher.rb
+- lib/impression/jamstack.rb
 - lib/impression/pages.rb
 - lib/impression/request_extensions.rb
-- lib/impression/request_routing.rb
+- lib/impression/request_extensions/responses.rb
+- lib/impression/request_extensions/routing.rb
 - lib/impression/resource.rb
 - lib/impression/version.rb
 - test/helper.rb
+- test/jamstack/_layouts/article.rb
+- test/jamstack/_layouts/default.rb
+- test/jamstack/articles/a.md
+- test/jamstack/assets/js/a.js
+- test/jamstack/bar.html
+- test/jamstack/baz/index.md
+- test/jamstack/foo.rb
+- test/jamstack/index.md
 - test/run.rb
 - test/static/bar/index.html
 - test/static/foo.html
@@ -191,6 +215,7 @@ files:
 - test/test_app.rb
 - test/test_file_tree.rb
 - test/test_file_watcher.rb
+- test/test_jamstack.rb
 - test/test_resource.rb
 homepage: http://github.com/digital-fabric/impression
 licenses:

data/lib/impression/request_routing.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-
-module Impression
-  
-  # Request routing extensions for `Qeweney::Request`
-  module RequestRouting
-
-    # Matches a route regexp against the relative request path. The relative
-    # request path is a separate string (stored in `@resource_relative_path`)
-    # that is updated as routes are matched against it. The `route_regexp`
-    # should be either `nil` for root routes (`/`) or a Regexp of the form
-    # `/^#{route}(\/.*)?$/`. See also `Resource#initialize`.
-    #
-    # @param route_regexp [Regexp, nil] Route regexp to match against
-    # @return [String, nil] The remainder of the path (relative to the route)
-    def match_resource_path?(route_regexp)
-      @resource_relative_path ||= path.dup
-
-      return @resource_relative_path unless route_regexp
-
-      # Simplified logic: no match returns nil, otherwise we set the relative path for 
-      @resource_relative_path = match_resource_relative_path(
-        @resource_relative_path, route_regexp
-      )
-    end
-
-    # Returns the relative_path for the latest matched resource
-    #
-    # @return [String]
-    def resource_relative_path
-      @resource_relative_path ||= path.dup
-    end
-
-    private
-
-    # Matches the given path against the given route regexp. If the path matches
-    # the regexp, the relative path for the given route is returned. Otherwise,
-    # this method returns `nil`.
-    #
-    # @param path [String] path to match
-    # @param route_regexp [Regexp] route regexp to match against
-    # @return [String, nil] the relative path for the given route, or nil if no match.
-    def match_resource_relative_path(path, route_regexp)
-      match = path.match(route_regexp)
-      match && (match[1] || '/')
-    end
-  end
-end