impression 0.10 → 0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 718a8a8eba181a00e5519e970d34bfc2e666ea15bacf0e72bffba450f3c9788d
-  data.tar.gz: fd665341a6fdcf66af4c564a269022f5fce014243a8736cf228188f9b3ca3e1f
+  metadata.gz: 7dff68cd22a426ae305742591ca09a3aa737cf453af1f186a54170671170f250
+  data.tar.gz: 920c5ca0698212f318dcc967cc09405e0b2f25e8d8521580c2fce331a4bfe982
 SHA512:
-  metadata.gz: 32ce3395a8f74e463b935e48711ae2b3fccd756b1bd3ec11912539ed2d969e0691dc044933548c5321a89749ad4faf3ddfc546958a83716d339b6fbeea0739b8
-  data.tar.gz: c33b519b8fd5a2a5da76e0d1a4a78854a0178dee62d90b143bf7cd8358150e69127af9d42832cb6158b41835cf6fa08cb6fc3efc09d0caa437e03b1e43722cde
+  metadata.gz: 98d8b4da9955eb4ac433cb74c45b9edeae759850e3a2b28cb4933f4445d554c25a360f968323f1a7a6db0bd9e748a2570048efc698a88803ac86920d77452757
+  data.tar.gz: e9e91a9fb0e9754fef82946f6a26368e53eb6c131d1e5d2ac0fe6e46274b75787cd2c47ee352a4dd015fd402ee2895fbfef2be1b7b01d84b8e3327ff91d18010

data/.github/workflows/test.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ${{matrix.os}}
 
     env:
-      POLYPHONY_USE_LIBEV: "1"
+      POLYPHONY_LIBEV: "1"
 
     steps:
     - name: Setup machine
@@ -25,8 +25,7 @@ jobs:
       uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{matrix.ruby}}
-        bundler-cache: true # 'bundle install' and cache
-        cache-version: 1
-        
+        bundler-cache: true
+        cache-version: 4
     - name: Run tests
       run:  bundle exec rake test

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.13 2022-04-05
+
+- Prevent race condiution on loading Ruby modules
+
+## 0.12 2022-02-16
+
+- Implement `RackApp` resource class (#16)
+
+## 0.11 2022-02-10
+
+- Update Tipi
+
 ## 0.10 2022-02-10
 
 - Add support for resource modules in Jamstack (#13)

data/Gemfile

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

data/Gemfile.lock

@@ -1,12 +1,12 @@
 PATH
   remote: .
   specs:
-    impression (0.10)
+    impression (0.13)
       modulation (~> 1.1)
-      papercraft (~> 0.19)
-      polyphony (~> 0.77)
-      qeweney (~> 0.17)
-      tipi (~> 0.49)
+      papercraft (~> 0.23)
+      polyphony (~> 0.93)
+      qeweney (~> 0.18)
+      tipi (~> 0.52)
 
 GEM
   remote: https://rubygems.org/
@@ -16,8 +16,8 @@ GEM
     docile (1.4.0)
     escape_utils (1.2.1)
     ever (0.1)
-    extralite (1.11)
-    faraday (1.9.3)
+    extralite (1.14)
+    faraday (1.10.0)
       faraday-em_http (~> 1.0)
       faraday-em_synchrony (~> 1.0)
       faraday-excon (~> 1.1)
@@ -40,25 +40,25 @@ GEM
     faraday-patron (1.0.0)
     faraday-rack (1.0.0)
     faraday-retry (1.0.3)
-    h1p (0.3)
+    h1p (0.5)
     http-2 (0.11.0)
     json (2.6.1)
-    kramdown (2.3.1)
+    kramdown (2.3.2)
       rexml
     kramdown-parser-gfm (1.1.0)
       kramdown (~> 2.0)
     localhost (1.1.9)
     minitest (5.11.3)
     modulation (1.1)
-    msgpack (1.4.4)
+    msgpack (1.4.5)
     multipart-post (2.1.1)
-    papercraft (0.19)
+    papercraft (0.24)
       escape_utils (~> 1.2.1)
       kramdown (~> 2.3.1)
       kramdown-parser-gfm (~> 1.1.0)
       rouge (~> 3.27.0)
-    polyphony (0.77)
-    qeweney (0.17)
+    polyphony (0.93)
+    qeweney (0.18)
       escape_utils (~> 1.2.1)
     rack (2.2.3)
     rake (12.3.3)
@@ -70,16 +70,16 @@ GEM
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.2)
-    tipi (0.49)
+    tipi (0.52)
       acme-client (~> 2.0.9)
       ever (~> 0.1)
-      extralite (~> 1.2)
-      h1p (~> 0.3)
+      extralite (~> 1.14)
+      h1p (~> 0.4)
       http-2 (~> 0.11)
       localhost (~> 1.1.4)
       msgpack (~> 1.4.2)
-      polyphony (~> 0.77)
-      qeweney (~> 0.16)
+      polyphony (~> 0.80)
+      qeweney (~> 0.18)
       rack (>= 2.0.8, < 2.3.0)
       websocket (~> 1.2.8)
     websocket (1.2.9)

data/README.md

@@ -19,20 +19,90 @@
 ## What is Impression
 
 > Impression is still in a very early stage of development. Things might not
-> correctly, or not at all.
+> work correctly.
 
 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.
+a minimalistic 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.
+## Resources
+
+The main abstraction in Impression is the resource - which represents an web
+endpoint that is mounted at a specific location in the URL namespace, and
+responds to requests. Resources can be nested in order to create arbitrarily
+complex routing trees. Impression provides multiple resource types, each
+customized for a specific use case, be it a JSON API, a set of MVC-style
+controllers, or a Markdown-based blog with static content.
+
+Finally, any kind of resource can be used as an Impression app. Routing is
+performed automatically according to the resource tree, starting from the root
+resource.
+
+## The request-response cycle
+
+The handling of incoming HTTP requests is done in two stages. First the request
+is routed to the corresponding resource, which then handles the request by
+generating a response.
+
+HTTP requests and responses use the
+[Qeweney](https://github.com/digital-fabric/qeweney) API.
+
+## Resource types
+
+Impression provides the following resources:
+
+- `Resource` - a generic resource.
+- `FileTree` - a resource serving static files from the given directory.
+- `App` - a resource serving static files, markdown files with layouts and Ruby
+  modules from the given directory.
+- `RackApp` - a resource serving the given Rack app.
+
+## Setting up a basic resource
+
+To setup a generic resource, call `Impression.resource` and provide a request
+handler:
+
+```
+app = Impression.resource { |req| req.respond('Hello, world!') }
+```
+
+## Running your app with Tipi
 
 Impression is made for running on top of
-[Tipi](https://github.com/digital-fabric/tipi), a new all-in-one web server for
-Ruby.
+[Tipi](https://github.com/digital-fabric/tipi). Your Tipi app file would like
+something like the following:
+
+```ruby
+# app.rb
+app = Impression.resource { |req| req.respond('Hello, world!') }
+Tipi.run(&app)
+```
+
+You can then start Tipi by running `tipi run app.rb`.
+
+## Running your app with a Rack app server
+
+You can also run your app on any Rack app server, using something like the
+following:
+
+```ruby
+app = Impression.resource { |req| req.respond('Hello, world!') }
+run Qeweney.rack(&app)
+```
+
+## Creating a routing map with resources
+
+A resource can be mounted at any point in the app's URL space. Resources can be
+nested within other resources by passing a `parent:` argument when creating a
+resource:
+
+```ruby
+app = Impression.app { |req| req.respond('Homepage') }
+greeter = Impression.resource(parent: app, path: 'greeter')
+static = Impression.file_tree(parent: app, path: 'static', directory: __dir__)
+```
 
 ## I want to know more
 

data/impression.gemspec

@@ -20,11 +20,11 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.required_ruby_version = '>= 2.6'
 
-  s.add_runtime_dependency      'polyphony',            '~>0.77'
-  s.add_runtime_dependency      'tipi',                 '~>0.49'
-  s.add_runtime_dependency      'qeweney',              '~>0.17'
+  s.add_runtime_dependency      'polyphony',            '~>0.93'
+  s.add_runtime_dependency      'tipi',                 '~>0.52'
+  s.add_runtime_dependency      'qeweney',              '~>0.18'
   
-  s.add_runtime_dependency      'papercraft',           '~>0.19'
+  s.add_runtime_dependency      'papercraft',           '~>0.23'
   s.add_runtime_dependency      'modulation',           '~>1.1'
 
   

data/lib/impression/app.rb

@@ -1,9 +1,330 @@
 # frozen_string_literal: true
 
+require 'fileutils'
+require 'date'
+require 'yaml'
+require 'modulation'
+require 'papercraft'
+
+require_relative './resource'
+require_relative './file_tree'
+
 module Impression
-  class App < Resource
-    def initialize(path: '/', **opts)
-      super(path: path, **opts)
+
+  # `App` implements a resource that maps to a generic app directory.
+  class App < FileTree
+    def initialize(**props)
+      super
+      @layouts = {}
+      @file_info_loader = spin { run_file_info_loader }
+    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| get_path_info(File.join(dir, fn)) }# page_entry(fn, dir) }
+        .sort_by { |i| i[:path] }
+    end
+
+    private
+
+    DATE_REGEXP = /(\d{4}\-\d{2}\-\d{2})/.freeze
+    FRONT_MATTER_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
+
+    YAML_OPTS = {
+      permitted_classes: [Date],
+      symbolize_names: true
+    }.freeze
+
+    # Runs a file info loader handling incoming requests for file info. This
+    # method is run in a fiber setup in #initialize.
+    #
+    # @return [void]
+    def run_file_info_loader
+      loop do
+        peer, path = receive
+        begin
+          info = calculate_path_info(path)
+          peer << info
+        rescue Polyphony::BaseException
+          raise
+        rescue => e
+          peer.raise(e)
+        end
+      end
+    end
+
+    def safe_calculate_path_info(path)
+      @file_info_loader << [Fiber.current, path]
+      receive
+    end
+
+    # Returns the path info for the given relative path.
+    #
+    # @param path [String] relative path
+    # @return [Hash] path info
+    def get_path_info(path)
+      @path_info_cache[path] ||= safe_calculate_path_info(path)
+    end
+
+    # Returns complete file info for Markdown files
+    #
+    # @param info [Hash] file info
+    # @param path [String] file path
+    # @return [Hash] file info
+    def file_info_md(info, path)
+      atts, content = parse_markdown_file(path)
+      info = info.merge(atts)
+      info[:html_content] = Papercraft.markdown(content)
+      info[:kind] = :markdown
+      if !info[:date] && (m = path.match(DATE_REGEXP))
+        info[:date] = Date.parse(m[1])
+      end
+      info
+    end
+
+    # Returns complete file info for Ruby files
+    #
+    # @param info [Hash] file info
+    # @param path [String] file path
+    # @return [Hash] file info
+    def file_info_rb(info, path)
+      info.merge(
+        kind: :module,
+        module: import(path)
+      )
+    end
+
+    # Returns the path info for the given file path.
+    #
+    # @param path [String] file path
+    # @return [Hash] path info
+    def file_info(path)
+      info = super
+      case info[:ext]
+      when '.md'
+        file_info_md(info, path)
+      when '.rb'
+        file_info_rb(info, path)
+      else
+        info
+      end
+    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
+      relative_path == '/' ? absolute_path : File.join(absolute_path, relative_path)
+    end
+
+    # Renders a response according to the given path info.
+    # 
+    # @param req [Qeweney::Request] request
+    # @param path_info [Hash] path info
+    # @return [void]
+    def render_from_path_info(req, path_info)
+      case (kind = path_info[:kind])
+      when :not_found
+        mod_path_info = up_tree_resource_module_path_info(req, path_info)
+        if mod_path_info
+          render_module(req, mod_path_info)
+        else
+          req.respond(nil, ':status' => Qeweney::Status::NOT_FOUND)
+        end
+      when :module
+        render_module(req, path_info)
+      when :markdown
+        render_markdown_file(req, path_info)
+      when :file
+        render_file(req, path_info)
+      else
+        raise "Invalid path info kind #{kind.inspect}"
+      end
+    end
+
+    # Returns the path info for an up-tree resource module, or false if not
+    # found. the :up_tree_resource_module_path_info KV can be either:
+    # - nil (default): up tree module search has not been performed.
+    # - false: no up tree module was found.
+    # - module path info: up tree module info (subsequent requests will be
+    #   directly routed to the module).
+    #
+    # @param req [Qeweney::Request] request
+    # @param path_info [Hash] path info
+    # @return [Hash, false] up-tree resource module path info
+    def up_tree_resource_module_path_info(req, path_info)
+      if path_info[:up_tree_resource_module_path_info].nil?
+        if (mod_path_info = find_up_tree_resource_module(req, path_info))
+          path_info[:up_tree_resource_module_path_info] = mod_path_info
+          return mod_path_info;
+        else
+          path_info[:up_tree_resource_module_path_info] = false
+          return false
+        end
+      end
+      path_info[:up_tree_resource_module_path_info]
+    end
+
+    # Performs a recursive search for an up-tree resource module from the given
+    # path info. If a resource module is found up the tree, its path_info is
+    # returned, otherwise returns nil.
+    # 
+    # @param req [Qeweney::Request] request
+    # @param path_info [Hash] path info
+    # @return [Hash, nil] up-tree resource module path info
+    def find_up_tree_resource_module(req, path_info)
+      relative_path = req.resource_relative_path
+
+      while relative_path != path
+        up_tree_path = File.expand_path('..', relative_path)
+        return nil if up_tree_path == relative_path
+
+        up_tree_path_info = get_path_info(up_tree_path)
+        case up_tree_path_info[:kind]
+        when :not_found
+          relative_path = up_tree_path
+          next
+        when :module
+          return up_tree_path_info
+        else
+          return nil
+        end
+      end
+      nil
+    end
+
+    # Renders a file response for the given request and the given path info,
+    # according to the file type.
+    #
+    # @param req [Qeweney::Request] request
+    # @param path_info [Hash] path info
+    # @return [void]
+    # def render_file(req, path_info)
+    #   case path_info[:kind]
+    #   else
+    #     req.serve_file(path_info[:path])
+    #   end
+    # end
+
+    # Renders a module. If the module is a Resource, it is mounted, and then the
+    # request is rerouted from the new resource and rendered. If the module is a
+    # Proc or a Papercraft::Template, it is rendered as such. Otherwise, an
+    # error is raised.
+    #
+    # @param req [Qeweney::Request] request
+    # @param path_info [Hash] path info
+    # @return [void]
+    def render_module(req, path_info)
+      # p render_module: path_info
+      case (mod = path_info[:module])
+      when Module
+        resource = mod.resource
+        resource.remount(self, path_info[:url])
+        # p path_info_url: path_info[:url], relative_path: req.resource_relative_path
+        relative_url = path_info[:url].gsub(/^#{path}/, '')
+        # p relative_url: relative_url
+        req.recalc_resource_relative_path(relative_url)
+        # p resource_relative_path: req.resource_relative_path
+        resource.route(req).call(req)
+      when Impression::Resource
+        mod.remount(self, path_info[:url])
+        req.recalc_resource_relative_path(path_info[:url])
+        mod.route(req).call(req)
+      when Proc, Papercraft::Template
+        render_papercraft_module(req, mod)
+      else
+        raise "Unsupported module type #{mod.class}"
+      end
+    end
+
+    # Renders a Papercraft module.
+    #
+    # @param mod [Module] Papercraft module
+    # @param path_info [Hash] path info
+    # @return [void]
+    def render_papercraft_module(req, mod)
+      template = Papercraft.html(mod)
+      body = template.render(request: req, resource: self)
+      req.respond(body, 'Content-Type' => template.mime_type)
+    end
+
+    # Renders a markdown file using a layout.
+    #
+    # @param req [Qeweney::Request] reqest
+    # @param path_info [Hash] path info
+    # @return [void]
+    def render_markdown_file(req, path_info)
+      layout = get_layout(path_info[:layout])
+
+      html = layout.render(request: req, resource: self, **path_info) {
+        emit path_info[:html_content]
+      }
+      req.respond(html, 'Content-Type' => layout.mime_type)
+    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::Template] 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)
+      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
+
+    # 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/file_tree.rb

@@ -14,8 +14,8 @@ module Impression
     #
     # @param directory [String] static directory path
     # @return [void]
-    def initialize(directory:, **props)
-      super(**props)
+    def initialize(directory: nil, **props, &block)
+      super(**props, &block)
       @directory = directory
       @path_info_cache = {}
     end
@@ -25,6 +25,8 @@ module Impression
     # @param req [Qeweney::Request] request
     # @return [void]
     def call(req)
+      return super if @directory.nil?
+
       path_info = get_path_info(req.resource_relative_path)
       render_from_path_info(req, path_info)
     end

data/lib/impression/rack_app.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tipi'
+require_relative './resource'
+
+module Impression
+
+  # The `RackApp` class represents Rack apps as resources.
+  class RackApp < Resource
+    def initialize(app: nil, **props, &block)
+      raise "No Rack app given" unless app || block
+
+      # We pass nil as the block, otherwise the block will pass to
+      # Resource#initialize, which will cause #call to be overidden.
+      super(**props, &nil) 
+      @handler = Tipi::RackAdapter.run(app || block)
+    end
+
+    def call(req)
+      if @path != '/'
+        req.rewrite!(@path, '/')
+      end
+      @handler.(req)
+    end
+  end
+end

data/lib/impression/version.rb

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