impression 0.1 → 0.5

data/lib/impression/jamstack.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+require 'date'
+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
+
+    # Returns a list of pages found in the given directory (relative to the base
+    # directory). Each entry containins the absolute file path, the pretty URL,
+    # the possible date parsed from the file name, and any other front matter
+    # attributes (for .md files). This method will detect only pages with the
+    # extensions .html, .md, .rb. The returned entries are sorted by file path.
+    #
+    # @param dir [String] relative directory
+    # @return [Array<Hash>] array of page entries
+    def page_list(dir)
+      base = File.join(@directory, dir)
+      Dir.glob('*.{html,md}', base: base)
+        .map { |fn| page_entry(fn, dir) }
+        .sort_by { |i| i[:path] }
+    end
+
+    private
+
+    DATE_REGEXP = /^(\d{4}\-\d{2}\-\d{2})/.freeze
+    MARKDOWN_PAGE_REGEXP = /\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)/m.freeze
+    MD_EXT_REGEXP = /\.md$/.freeze
+    PAGE_EXT_REGEXP = /^(.+)\.(md|html|rb)$/.freeze
+    INDEX_PAGE_REGEXP = /^(.+)\/index$/.freeze
+
+    # Returns a page entry for the given file.
+    #
+    # @param fn [String] file name
+    # @param dir [String] relative directory
+    # @return [Hash] page entry
+    def page_entry(fn, dir)
+      relative_path = File.join(dir, fn)
+      absolute_path = File.join(@directory, relative_path)
+      info = {
+        path: absolute_path,
+        url: pretty_url(relative_path)
+      }
+      if fn =~ MD_EXT_REGEXP
+        atts, _ = parse_markdown_file(absolute_path)
+        info.merge!(atts)
+      end
+
+      if (m = fn.match(DATE_REGEXP))
+        info[:date] ||= Date.parse(m[1])
+      end
+
+      info
+    end
+
+    # Returns the pretty URL for the given relative path. For pages, the
+    # extension is removed. For index pages, the index suffix is removed.
+    #
+    # @param relative_path [String] relative path
+    # @return [String] pretty URL
+    def pretty_url(relative_path)
+      if (m = relative_path.match(PAGE_EXT_REGEXP))
+        relative_path = m[1]
+      end
+      if (m = relative_path.match(INDEX_PAGE_REGEXP))
+        relative_path = m[1]
+      end
+      File.join(absolute_path, relative_path)
+    end
+
+    # 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(request: req, resource: self)
+      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(request: req, resource: self, **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
+  
+    # 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) || ''
+      atts = {}
+
+      # Parse date from file name
+      if (m = path.match(DATE_REGEXP))
+        atts[:date] ||= Date.parse(m[1])
+      end
+
+      if (m = data.match(MARKDOWN_PAGE_REGEXP))
+        front_matter = m[1]
+        data = m.post_match
+        
+        YAML.load(front_matter).each_with_object(atts) do |(k, v), h|
+          h[k.to_sym] = v
+        end
+      end
+        
+      [atts, data]
+    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)
+      
+    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

@@ -2,8 +2,14 @@
 
 require 'qeweney'
 
-require_relative './pages'
+# require_relative './pages'
+require_relative './request_extensions/routing'
+require_relative './request_extensions/responses'
 
+# Extensions to `Qeweney::Request`
 class Qeweney::Request
-  include Impression::Pages::RequestMethods
+  
+  # include Impression::Pages::RequestMethods
+  include Impression::RequestExtensions::Routing
+  include Impression::RequestExtensions::Responses
 end

data/lib/impression/resource.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'qeweney'
+
+module Impression
+
+  # The `Resource` class represents an abstract web resource. Resources are
+  # organized in tree like structure, with the structure normally corresponding
+  # to the URL path hierarchy. Other ways of organising resources, according to
+  # other taxonomies, can be implemented as long as the resources implement the
+  # same interface as the `Resource` class, which includes the following
+  # methods:
+  #
+  # - `Resource#route` - returns the resource which should respond to the
+  #   request.
+  # - `Resource#respond` - responds to the request.
+  #
+  class Resource
+    # Reference to the parent resource
+    attr_reader :parent
+
+    # The resource's path relative to its parent
+    attr_reader :path
+
+    # A hash mapping relative paths to child resources
+    attr_reader :children
+
+    # Initalizes a new resource instance.
+    #
+    # @param parent [Impression::Resource, nil] the parent resource (or nil)
+    # @param path [String] the resource's relative path
+    # @return [void]
+    def initialize(parent: nil, path:)
+      @parent = parent
+      @path = normalize_route_path(path)
+      @route_regexp = @path == '/' ? nil : /^#{@path}(\/.*)?$/.freeze
+      @children = {}
+
+      @parent&.add_child(self)
+    end
+
+    # Returns the resource's absolute path, according to its location in the
+    # resource hierarchy.
+    #
+    # @return [String] absolute path
+    def absolute_path
+      @absoulte_path ||= File.join(@parent ? @parent.absolute_path : '/', @path)
+    end
+
+    # Iterates over the resource and any of its sub-resources, passing each to
+    # the given block.
+    # 
+    # @return [Impression::Resource] self
+    def each(&block)
+      block.(self)
+      @children.values.each { |c| c.each(&block) }
+      self
+    end
+
+    # Adds a child reference to the children map.
+    #
+    # @param child [Impression::Resource] child resource
+    # @return [Impression::Resource] self
+    def add_child(child)
+      @children[child.path] = child
+      self
+    end
+
+    # Responds to the given request by rendering a 404 Not found response.
+    #
+    # @param req [Qeweney::Request] request
+    # @return [void]
+    def call(req)
+      req.respond(nil, ':status' => Qeweney::Status::NOT_FOUND)
+    end
+
+    FIRST_PATH_SEGMENT_REGEXP = /^(\/[^\/]+)\//.freeze
+
+    # Routes the request by matching self and any children against the request
+    # path, returning the target resource, or nil if there's no match.
+    #
+    # @param req [Qeweney::Request] request
+    # @return [Impression::Resource, nil] target resource
+    def route(req)
+      case (relative_path = req.match_resource_path?(@route_regexp))
+      when nil
+        return nil
+      when '/'
+        return self
+      else
+        # naive case
+        child = @children[relative_path]
+        return child.route(req) if child
+
+        if (m = relative_path.match(FIRST_PATH_SEGMENT_REGEXP))
+          child = @children[m[1]]
+          return child.route(req) if child
+        end
+
+        return self
+      end
+    end
+
+    # Renders the resource and all of its sub-resources to static files.
+    #
+    # @param base_path [String] base path of target directory
+    # @return [Impression::Resource] self
+    def render_tree_to_static_files(base_path)
+      each do |r|
+        path = File.join(base_path, r.relative_static_file_path)
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) if !File.directory?(dir)
+        File.open(path, 'w') { |f| r.render_to_file(f) }
+      end
+      self
+    end
+
+    # Converts the resource to a Proc, for use as a Qeweney app.
+    #
+    # @return [Proc] web app proc
+    def to_proc
+      ->(req) do
+        resource = route(req) || self
+        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
+
+    # Normalizes the given path by ensuring it starts with a slash.
+    #
+    # @param path [String] path to normalize
+    # @return [String] normalized path
+    def normalize_route_path(path)
+      path =~ SLASH_PREFIXED_PATH_REGEXP ? path : "/#{path}"
+    end
+  end
+end

data/lib/impression/version.rb

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

data/lib/impression.rb

@@ -1,3 +1,11 @@
 # frozen_string_literal: true
 
+require 'polyphony'
+
 require_relative './impression/request_extensions'
+# require_relative './impression/file_watcher'
+
+require_relative './impression/resource'
+require_relative './impression/file_tree'
+require_relative './impression/jamstack'
+require_relative './impression/app'

data/test/helper.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require_relative './coverage' if ENV['COVERAGE']
+require 'minitest/autorun'
+require 'impression'
+require 'qeweney/test_adapter'
+
+module Kernel
+  def mock_req(**args)
+    Qeweney::TestAdapter.mock(**args)
+  end
+
+  def capture_exception
+    yield
+  rescue Exception => e
+    e
+  end
+
+  def trace(*args)
+    STDOUT.orig_write(format_trace(args))
+  end
+
+  def format_trace(args)
+    if args.first.is_a?(String)
+      if args.size > 1
+        format("%s: %p\n", args.shift, args)
+      else
+        format("%s\n", args.first)
+      end
+    else
+      format("%p\n", args.size == 1 ? args.first : args)
+    end
+  end
+end
+
+module Minitest::Assertions
+  def assert_in_range exp_range, act
+    msg = message(msg) { "Expected #{mu_pp(act)} to be in range #{mu_pp(exp_range)}" }
+    assert exp_range.include?(act), msg
+  end
+
+  def assert_response exp_body, exp_content_type, req
+    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
+    actual = req.response_content_type
+    assert_equal exp_content_type, actual
+  end
+end
+
+class Impression::Resource
+  def route_and_call(req)
+    route(req).call(req)
+  end
+end
+
+class PathRenderingResource < Impression::Resource
+  def call(req)
+    req.respond(absolute_path)
+  end
+end
+
+class CompletePathInfoRenderingResource < Impression::Resource
+  def call(req)
+    req.respond("#{absolute_path} #{req.resource_relative_path}")
+  end
+end
+
+# Extensions to be used in conjunction with `Qeweney::TestAdapter`
+class Qeweney::Request
+  def response_headers
+    adapter.headers
+  end
+
+  def response_body
+    adapter.body
+  end
+
+  def response_status
+    adapter.status
+  end
+
+  def response_content_type
+    response_headers['Content-Type']
+  end
+end
+
+puts "Polyphony backend: #{Thread.current.backend.kind}"

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/2008-06-14-manu.md

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

data/test/jamstack/articles/2009-06-12-noatche.md

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

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/foobar.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+layout = import('./_layouts/default')
+
+export_default layout.apply(title: 'Foobar') { |resource:, request:, **props|
+  h1 request.query[:q]
+  resource.page_list('/articles').each do |i|
+    a i[:title], href: i[:url]
+  end
+}

data/test/jamstack/index.md

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

data/test/run.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir.glob("#{__dir__}/test_*.rb").each do |path|
+  require(path)
+end

data/test/static/bar/index.html

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

data/test/static/foo.html

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

data/test/static/index.html

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

data/test/static/js/a.js

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