rack-server-pages 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b986555fd3422b75ae3b118c60d66db359f84298dd06cbc43fac84b036071fee
-  data.tar.gz: 8e2a767d6ab041393514115fc1bc106d9b97b881ae4f061d47e99cae5cb6cdd2
+  metadata.gz: e901e5e22aabc19775de43f94a34d3ae8a8b27a4469db4563f9e78052350cc38
+  data.tar.gz: b853d1e26f38fd0ecb79c53f51415d5e907a30ce5c7ab5b9e92e2697f1539897
 SHA512:
-  metadata.gz: 6e46b7346feca13de17285d305f54f2de30737eae130cf4e676e55349e63572340f6d30dd66fa0b18020926db5c91dece865b374e6dd165d605d78459924fbc4
-  data.tar.gz: 9971d0027f89f8f47960c7ac0725af41288ef5c38b923bda5cfe74510bd627b7d5703ad9d9adc3379b76a3d09d5e2bb2a367014fb80d87b3d266dc29fab6bea3
+  metadata.gz: c6f387713227b1a9d7495d8763b6817305882999484fb0318d25fccd610781ff70222138d740a86f9cc3d716a55b336db3b33285e6ef9fdf24f27c88c56d91e8
+  data.tar.gz: 8fac86b85b2a9bb9aef795faf61036c2479ffe83171c4a3d2e63f6f096d19eb882f8f5128c51abccb1a08011fc3e31a6dfd087cd1a31dfadd6aaf74f7feaf4c7

data/CHANGES.md

@@ -1,13 +1,26 @@
 CHANGES
 =======
 
-### [v0.2.1](https://github.com/migrs/rack-server-pages/releases/tag/v0.2.1) / 2025-08-31
+### [v0.3.0](https://github.com/migrs/rack-server-pages/releases/tag/v0.3.0) / 2026-10-25
 
-  * [Changes](https://github.com/migrs/rack-server-pages/compare/v0.2.0...v0.2.1)
+  * [Changes](https://github.com/migrs/rack-server-pages/compare/v0.2.1...v0.3.0)
 
   * Feature
+    - Add content-versioned asset URLs, `static_etags` and `static_timestamps` (both enabled by default), and configurable static cache headers. See [UPGRADING](UPGRADING.md) for caching changes.
+
+  * Bugfix
+    - Detect the loaded Tilt template API rather than an incomplete namespace created by another dependency.
 
   * Misc
+    - Enable line and branch coverage with SimpleCov and publish coverage to Coveralls from CI.
+    - Refresh the README, move its backlog into GitHub issues, and document rendering a template with `halt`.
+    - Modernize GitHub Actions and test Ruby 3.0 through 3.4 and 4.0 against Rack 2.2 and 3 with headless Firefox.
+
+### [v0.2.1](https://github.com/migrs/rack-server-pages/releases/tag/v0.2.1) / 2025-08-31
+
+  * [Changes](https://github.com/migrs/rack-server-pages/compare/v0.2.0...v0.2.1)
+
+  * Bugfix
     - Stop using `Rack::Logger`
 
 ### [v0.2.0](https://github.com/migrs/rack-server-pages/releases/tag/v0.2.0) / 2024-10-19

data/README.md

@@ -1,18 +1,20 @@
 Rack Server Pages
 =================
 
-Rack middleware and application for serving dynamic pages in very simple way.
-There are no controllers or models, just only views like a jsp, asp and php!
+Rack middleware and application for serving dynamic pages without controllers or models, using templates similar to JSP, ASP, and PHP. Requests map directly to files in your view directories. Built-in ERB works without extra runtime dependencies beyond Rack; Tilt and additional template engines are optional.
 
-<http://github.com/migrs/rack-server-pages>
+<https://github.com/migrs/rack-server-pages>
 
 [![Build Status](https://github.com/migrs/rack-server-pages/actions/workflows/test.yml/badge.svg)](https://github.com/migrs/rack-server-pages/actions/workflows/test.yml)
-[![Gem Version](https://badge.fury.io/rb/rack-server-pages.svg)](http://badge.fury.io/rb/rack-server-pages)
+[![Coverage Status](https://coveralls.io/repos/github/migrs/rack-server-pages/badge.svg?branch=master)](https://coveralls.io/github/migrs/rack-server-pages?branch=master)
+[![Gem Version](https://badge.fury.io/rb/rack-server-pages.svg)](https://badge.fury.io/rb/rack-server-pages)
 
 ## Features
 
 - Serving dynamic pages (default: ERB)
 - Serving static files
+- Content-versioned asset URLs with `asset_path`
+- Configurable static-file caching with content-based `ETag` headers and timestamp validation
 - No requirements (except Rack)
 - Tilt support (optional)
 - Include a partial template
@@ -25,12 +27,16 @@ There are no controllers or models, just only views like a jsp, asp and php!
 
 ## Requirements
 
-- [Ruby](http://ruby-lang.org/) >= 2.2.2
-- [Rack](http://github.com/rack/rack)
+- [Ruby](https://www.ruby-lang.org/)
+- [Rack](https://github.com/rack/rack)
+
+CI tests Ruby 3.0 through 3.4 and 4.0 against Rack 2.2 and 3, including browser integration tests with headless Firefox. Selenium manages the browser driver automatically.
+
+The test suite collects line and branch coverage with SimpleCov before loading the library, including unexecuted files under `lib/`. Run `bundle exec rake spec` and open `coverage/index.html` to inspect the local report. CI publishes `coverage/.resultset.json` to Coveralls from the Ruby 4.0 / Rack 3 job only, so compatibility jobs do not overwrite each other's reports. Coverage output is ignored by Git.
 
 ## Install
 
-[RubyGems](http://rubygems.org/gems/rack-server-pages) available
+Available on [RubyGems](https://rubygems.org/gems/rack-server-pages):
 
 ```
 gem install rack-server-pages
@@ -83,29 +89,30 @@ And same as above.
 
 ## Template bindings
 
-- CoreHelper
-  - layout(file)
-  - partial(file)
-  - redirect(target, status=302) (same as [Sinatra](http://www.sinatrarb.com/intro#Browser%20Redirect))
-  - halt(\*args) (same as [Sinatra](http://www.sinatrarb.com/intro#Halting))
-  - url(path)
-
-- [Rack::Request](http://rack.rubyforge.org/doc/Rack/Request.html)
-  - request
-  - env
-  - params
-  - session
-  - cookies
-
-- [Rack::Response](http://rack.rubyforge.org/doc/Rack/Response.html)
-  - response
-  - headers
-  - set\_cookies
-  - delete\_cookie
-
-- [ERB::Util](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/erb/rdoc/ERB/Util.html)
-  - h (alias for: html\_escape)
-  - u (alias for: url\_encode)
+- `CoreHelper`
+  - `layout(file)`
+  - `partial(file)`
+  - `redirect(target, status=302)` (same as [Sinatra](http://www.sinatrarb.com/intro#Browser%20Redirect))
+  - `halt(*args)` (same as [Sinatra](http://www.sinatrarb.com/intro#Halting))
+  - `url(path)`
+  - `asset_path(path)`
+
+- [`Rack::Request`](https://www.rubydoc.info/gems/rack/Rack/Request)
+  - `request`
+  - `env`
+  - `params`
+  - `session`
+  - `cookies`
+
+- [`Rack::Response`](https://www.rubydoc.info/gems/rack/Rack/Response)
+  - `response`
+  - `headers`
+  - `set_cookies`
+  - `delete_cookie`
+
+- [`ERB::Util`](https://docs.ruby-lang.org/en/master/ERB/Util.html)
+  - `h` (alias for: `html_escape`)
+  - `u` (alias for: `url_encode`)
 
 ## Configurations
 
@@ -143,21 +150,148 @@ run Rack::ServerPages.new { |config|
 
 ### Options
 
-- view\_path
-  - Views folders to load templates from.
-  - default: [views, public]
+#### `view_path`
+
+Sets the directories searched for templates and static files, in priority order. Accepts one directory or an array; the first matching file is used.
+
+Default: `['views', 'public']`.
+
+```ruby
+config.view_path = ['site/views', 'site/public']
+```
+
+#### `effective_path`
+
+Limits file serving to a URL prefix and removes that prefix when resolving files. Requests outside the prefix fall through to the downstream or fallback application.
+
+Default: `nil` (no prefix).
+
+```ruby
+config.effective_path = '/pages'
+```
+
+This serves `/pages/about.html` from `about.html` under a configured `view_path` directory.
+
+#### `default_charset`
+
+Sets the default charset in rendered template responses' `Content-Type` header. Does not convert file contents or change static-file headers.
+
+Default: `'utf-8'`.
+
+```ruby
+config.default_charset = 'utf-8'
+```
+
+#### `cache_control`
+
+Sets the default `Cache-Control` response header for rendered templates, including generated CSS. A header explicitly set by a template or filter takes precedence. Static files use `static_cache_control` instead.
+
+Default: `nil` (no policy added).
+
+```ruby
+config.cache_control = 'private, no-store'
+```
+
+This prevents caching pages containing sensitive information.
+
+#### `static_cache_control`
+
+Sets the `Cache-Control` response header for static files such as CSS, JavaScript, and images. Rendered templates, including generated CSS, use `cache_control` instead.
+
+Default: `nil` (no policy added).
+
+```ruby
+config.static_cache_control = 'public, no-cache'
+```
+
+This allows caching but requires revalidation before reuse.
+
+#### `static_etags`
+
+Adds a content-based `ETag` response header to static files by hashing each file with SHA-256 on each request. A matching `If-None-Match` returns an empty `304` for `GET`/`HEAD` and takes precedence over `If-Modified-Since`.
+
+Default: `true`.
+
+```ruby
+config.static_etags = false
+```
+
+This disables content hashing, `ETag` generation, and `ETag` validation without disabling `static_timestamps` or `asset_path`.
+
+#### `static_timestamps`
+
+Honors `If-Modified-Since` on static requests using Rack's timestamp-based conditional handling, unless enabled `static_etags` validation takes precedence.
+
+Default: `true`.
+
+```ruby
+config.static_timestamps = false
+```
+
+This ignores `If-Modified-Since` when deployment timestamps are unreliable. The `Last-Modified` response header and `static_etags` validation are unaffected.
+
+#### `failure_app`
+
+Sets a fallback Rack application for requests that do not resolve to a template or static file. When used as middleware, the downstream application takes precedence over this setting.
+
+Default: `nil` (uses the built-in `404` response when no downstream application is supplied).
 
-- effective\_path
-  - default: nil
+```ruby
+config.failure_app = ->(_env) { [404, { 'content-type' => 'text/plain' }, ['Page not found']] }
+```
+
+#### `show_exceptions`
+
+Controls whether template-rendering errors are raised to the caller or handled as a `500` response with `on_error` filters. Does not control a built-in error page.
+
+Default: `nil` (raises when `RACK_ENV` is unset or `'development'`; handles errors in other environments).
+
+```ruby
+config.show_exceptions = false
+```
+
+This handles template errors instead of raising them.
+
+### Versioned assets and browser caching
+
+Content-based `ETag` validation and versioned asset URLs work independently. With `static_etags = true` (the default), ordinary URLs such as `/styles.css` receive `ETag` headers and support `If-None-Match` without using `asset_path`. However, validators only help when the browser makes a request; they cannot prevent reuse of an asset that the browser considers fresh. `asset_path` changes the URL when the file contents change, so a browser fetching fresh HTML requests the new asset URL instead of reusing the old one. Use both for stronger stale-asset protection.
+
+Use `asset_path` instead of a fixed local asset URL in templates:
+
+```erb
+<link rel="stylesheet" href="<%= h asset_path('/styles.css') %>">
+<script src="<%= h asset_path('/scripts/app.js') %>"></script>
+<img src="<%= h asset_path('/img/logo.png') %>" alt="Logo">
+```
 
-- default\_charset
-  - default: utf-8
+The helper adds a SHA-256 content fingerprint, for example `/styles.css?v=...`. Changed file contents produce a new URL even when a deployment preserves file timestamps and sizes. Existing query parameters and fragments are preserved, and an existing `v` parameter is replaced. Paths are relative to the configured view paths; application mounts (`SCRIPT_NAME`) and `effective_path` are included automatically. Missing files raise `Errno::ENOENT`; external URLs and parent-directory traversal are rejected.
 
-- cache\_control
-  - default: nil
+Configure browser revalidation explicitly:
+
+```ruby
+use Rack::ServerPages do |config|
+  config.cache_control = 'private, no-cache'
+  config.static_cache_control = 'public, no-cache'
+end
+```
 
-- failure\_app
-  - default: nil
+Both settings default to `nil`, preserving the existing cache-policy defaults. `no-cache` permits storage but requires revalidation before reuse; use `private, no-store` instead for templates containing sensitive account or payment information. These settings do not change cache headers on the downstream application.
+
+By default, static responses include content-based `ETag` headers, hashing the file on each request. Matching `If-None-Match` requests return an empty `304` response. When both validators are present, `If-None-Match` takes precedence over `If-Modified-Since`, so a changed file is returned for an old `ETag` even if its modification time is unchanged. Requests with only `If-Modified-Since` retain Rack's timestamp-based conditional handling.
+
+Set `config.static_etags = false` to disable content hashing and content-based `ETag` validation. With the default timestamp-validation setting, this restores Rack's original static-file conditional handling. `static_cache_control` still applies, and `asset_path` remains available independently. See [UPGRADING](UPGRADING.md) when updating from an earlier release.
+
+`static_timestamps` also defaults to `true`. Set `config.static_timestamps = false` to ignore timestamp-based request validation when deployment timestamps are unreliable. This does not remove the `Last-Modified` response header or disable `ETag` validation. Set both options to `false` to disable both conditional checks.
+
+Use the helper for local images, fonts, icons, and other assets too. For URLs inside CSS, rename the stylesheet to `styles.css.erb` and render those references explicitly:
+
+```erb
+.hero { background-image: url("<%= asset_path('/img/background.svg') %>"); }
+```
+
+Continue linking to `/styles.css` through `asset_path`. The fingerprint identifies the selected source file; generated CSS must also use `cache_control = 'private, no-cache'` so changes to a referenced image are picked up even when the CSS template itself has not changed. Referenced files are not rewritten automatically, and no build pipeline is needed.
+
+Do not set `immutable` or a long freshness lifetime for these query-versioned URLs: the middleware serves the current file, not an archive of old versions. This mechanism does not force an already-open page to reload; the new URLs take effect when it fetches fresh HTML.
 
 ### Helpers
 
@@ -173,7 +307,7 @@ use Rack::ServerPages do |config|
 end
 ```
 
-in view file (erb)
+in view file (`.erb`)
 
 ```erb
 <%= three_times('blah') %>
@@ -211,7 +345,7 @@ end
 
 ### Filters
 
-with before/after block
+with `before`/`after` block
 
 ```ruby
 use Rack::ServerPages do |config|
@@ -238,7 +372,7 @@ use Rack::ServerPages do |config|
 end
 ```
 
-if you define before/after method in helper module, it will be treated as filters
+if you define a `before`/`after` method in a helper module, it will be treated as a filter
 
 ```ruby
 module SampleHelper
@@ -262,9 +396,26 @@ in view file
 <%= three_times(@title) %>
 ```
 
+### Rendering a template with `halt`
+
+`partial` returns a rendered string, so pass its result to `halt` as the response body. For example, create `views/forbidden.html.erb`:
+
+```erb
+<h1><%= 'Forbidden' %></h1>
+```
+
+Inside a `before` filter, helper, or template, return that page with the desired status and content type:
+
+```ruby
+halt 403, { Rack::CONTENT_TYPE => 'text/html; charset=utf-8' }, partial('views/forbidden.html')
+```
+
+Place the call inside your existing validation or authorization check. `partial` takes a filesystem path relative to the working directory, or an absolute path; it does not search `view_path` automatically. Omitting the final `.erb` suffix lets it find the template. `halt` skips normal page rendering, so automatic layouts are not applied to this response. The example works with both built-in ERB and Tilt.
+
 ## Tilt support
-[Tilt](http://github.com/rtomayko/tilt) is generic interface to multiple Ruby template engines.
-If you want to use Tilt, just `require 'tilt'` and require template engine libraries that you want.
+[Tilt](https://github.com/rtomayko/tilt) is a generic interface to multiple Ruby template engines. To use it, add Tilt and the desired engines to your dependencies, then explicitly require them:
+
+Tilt is selected only when its template lookup API is available. A `Tilt` namespace created by another dependency does not enable it or force it to load. Loading Tilt later enables it for subsequent requests unless you have explicitly disabled it with `Rack::ServerPages::Template.use_tilt(false)`.
 
 ```ruby
 require 'rack-server-pages'
@@ -273,7 +424,12 @@ require 'rdiscount' # markdown library
 run Rack::ServerPages
 ```
 
-or put your `Gemfile`
+If your application uses `Bundler.require`, the equivalent `Gemfile` entries are:
+
+```ruby
+gem 'tilt', require: 'tilt'
+gem 'rdiscount', require: 'rdiscount'
+```
 
 ### [Markdown](http://daringfireball.net/projects/markdown/)
 
@@ -468,21 +624,13 @@ At first, create sample file: `public/hello.erb` or `views/hello.html.erb`
 
 ### Rails
 
-Add to `config/environment.rb` (Rails2) or `config/application.rb` (Rails3)
+Add the middleware inside your application configuration in `config/application.rb`:
 
 ```ruby
 config.middleware.use Rack::ServerPages
 ```
 
-And run
-
-Rails2
-
-```
-script/server
-```
-
-Rails3
+Start Rails:
 
 ```
 rails s
@@ -520,15 +668,15 @@ ruby sinatra_sample.rb
 
 ### Customize file extension associations
 
-#### e.g. .php as ERB
+#### e.g. `.php` as ERB
 
-ERBTemplate (default)
+`ERBTemplate` (default)
 
 ```ruby
 Rack::ServerPages::Template::ERBTemplate.extensions << 'php'
 ```
 
-TiltTemplate (see. [Template Mappings](http://github.com/rtomayko/tilt))
+`TiltTemplate` (see. [Template Mappings](http://github.com/rtomayko/tilt))
 
 ```ruby
 Tilt.register Tilt::ERBTemplate, 'php'
@@ -542,25 +690,22 @@ And create `public/info.php` :)
 
 <http://localhost:9292/info.php>
 
-## Demo site
+## Development
+
+Clone the repository and install its development dependencies. RedCloth and BlueCloth are legacy optional test engines; the C17 build options let them compile when Ruby defaults to C23:
 
-<http://rack-server-pages.heroku.com/>
+```sh
+bundle config set --local build.RedCloth --with-cflags=-std=gnu17
+bundle config set --local build.bluecloth --with-cflags=-std=gnu17
+bundle install
+MOZ_HEADLESS=1 bundle exec rake
+```
 
-## ToDo
+The default task runs lint and the full suite. Browser examples require Firefox; Selenium manages its driver. Run `bundle exec rake spec` for only the tests.
 
-### Implements
-- Static file generator (for designer)
+Run the included application with `bundle exec rackup` and visit <http://localhost:9292/> or <http://localhost:9292/examples/> for local examples. There is no maintained hosted demo.
 
-### Tasks
-  - Tutorials
-    - for PHP user
-    - for Designer
-    - for Windows user
-  - More documents
-    - Deployment using apache / passenger / nginx
-  - Complete Tilt examples
-  - Philosophy
-  - Benchmark
+See [RELEASING](RELEASING.md) for the maintainer release process.
 
 ## License
 

data/RELEASING.md

@@ -0,0 +1,79 @@
+# Releasing Rack Server Pages
+
+Release bug fixes frequently, features less frequently, and breaking changes rarely.
+
+## Release
+
+Start from a clean, up-to-date canonical checkout on `master`. Confirm that `origin` points to `migrs/rack-server-pages`, the version in `lib/rack-server-pages/version.rb` matches the next heading in [CHANGES.md](CHANGES.md), and the version has not already been tagged or published to RubyGems.
+
+```sh
+git switch master
+git pull --ff-only origin master
+git status --short
+```
+
+Run lint and the complete test suite with Firefox available. Selenium manages its driver; use headless mode locally. See [Development](README.md#development) for dependency setup.
+
+```sh
+MOZ_HEADLESS=1 bundle exec rake
+```
+
+Also run the suite against Rack 2.2. The `RACK_VERSION` selector must be set when resolving dependencies and running tests:
+
+```sh
+RACK_VERSION='~> 2.2' bundle update rack rackup
+RACK_VERSION='~> 2.2' MOZ_HEADLESS=1 bundle exec rake spec
+```
+
+Return to the default Rack 3 dependencies afterward:
+
+```sh
+bundle update rack rackup
+```
+
+Review [UPGRADING.md](UPGRADING.md) for behavior changes. Replace `Next` in the release heading in `CHANGES.md` with the current date, preserving the existing `YYYY-MM-DD` format. Commit and push the release preparation:
+
+```sh
+git add CHANGES.md
+git commit -m "Preparing for release, 0.3.0."
+git push origin master
+```
+
+Wait for the release commit's [GitHub Actions](https://github.com/migrs/rack-server-pages/actions) checks to pass across the full Ruby/Rack matrix and lint. A successful build for a different commit is not sufficient.
+
+Publishing requires a maintainer's RubyGems credentials and may require a fresh one-time password (OTP). For an agent-assisted release, request the OTP immediately before publishing, after validation and CI complete. Never commit or log credentials or OTPs. With `OTP` holding a freshly supplied code:
+
+```sh
+GEM_HOST_OTP_CODE="$OTP" bundle exec rake release
+unset OTP
+```
+
+Bundler builds the gem in `pkg/`, creates the version tag, pushes the commit and tag, and publishes the gem. Verify that the remote tag points to the release commit and RubyGems lists the expected version. If a step fails, inspect what completed before retrying; never move a published release tag or overwrite a published version.
+
+Create a GitHub release from the tag, using the corresponding changelog entry as release notes and linking to the upgrade guide for behavior changes:
+
+```sh
+gh release create v0.3.0 --verify-tag --title "v0.3.0" --notes-file /path/to/release-notes.md
+```
+
+## Prepare the Next Version
+
+Increment the patch version in `lib/rack-server-pages/version.rb`, then add a new `Next` section at the top of `CHANGES.md`, updating both its release and comparison links:
+
+```markdown
+### [v0.3.1](https://github.com/migrs/rack-server-pages/releases/tag/v0.3.1) / Next
+
+  * [Changes](https://github.com/migrs/rack-server-pages/compare/v0.3.0...v0.3.1)
+
+  * Feature
+
+  * Bugfix
+
+  * Misc
+```
+
+```sh
+git add CHANGES.md lib/rack-server-pages/version.rb
+git commit -m "Preparing for next development iteration, 0.3.1."
+git push origin master
+```

data/UPGRADING.md

@@ -0,0 +1,23 @@
+# Upgrading
+
+## 0.2.x to 0.3.0
+
+### Static-file caching changes by default
+
+`static_etags` defaults to `true`. Static-file responses now include an ETag derived from a SHA-256 hash of the file contents. Matching `If-None-Match` validators return an empty `304` response for GET and HEAD. When both `If-None-Match` and `If-Modified-Since` are present, the ETag takes precedence: an old ETag produces a full response even if the file's timestamp is unchanged.
+
+Requests with only `If-Modified-Since` retain Rack's timestamp-based conditional handling, including `304` responses for matching timestamps. Such requests still rely on accurate modification times; adopt content-versioned asset URLs for protection against deployment tools that preserve or normalize timestamps.
+
+The file is read and hashed on each static request, adding disk and CPU work. To restore Rack's original static-file conditional handling without this content hashing, disable the option:
+
+```ruby
+use Rack::ServerPages do |config|
+  config.static_etags = false
+end
+```
+
+This omits content-based ETags and, with the default timestamp-validation setting, delegates conditional handling entirely to Rack. `static_cache_control` still applies when configured. Template responses and downstream applications are unaffected by this option.
+
+### Optional timestamp-validation opt-out
+
+`static_timestamps` defaults to `true`, preserving Rack's timestamp-only conditional responses. Set `config.static_timestamps = false` to ignore `If-Modified-Since` on static requests when modification times are unreliable. The `Last-Modified` response header is still emitted, and matching ETags can still produce a `304`. The switches are independent: set both `static_etags` and `static_timestamps` to `false` to disable both conditional checks. Neither option affects template responses or downstream applications.

data/lib/rack/server_pages.rb

@@ -4,6 +4,7 @@ require 'rack/utils'
 require 'rack/mime'
 require 'time'
 require 'forwardable'
+require 'digest/sha2'
 
 module Rack
   class ServerPages
@@ -39,10 +40,49 @@ module Rack
         @app
       else
         file = select_template_file(files)
-        (tpl = Template[file]) ? server_page(tpl) : Rack::Files.new(file.split(path_info).first)
+        (tpl = Template[file]) ? server_page(tpl) : static_file(file, path_info)
       end.call(env)
     end
 
+    module StaticFiles
+      def static_file(file, path_info)
+        root = file.split(path_info).first
+        return Rack::Files.new(root) unless ::File.file?(file) && ::File.readable?(file)
+
+        headers = static_headers(file)
+        files = Rack::Files.new(root, headers)
+        lambda do |env|
+          if @config.static_etags && %w[GET HEAD].include?(env['REQUEST_METHOD']) && matching_etag?(env['HTTP_IF_NONE_MATCH'], headers[Rack::ETAG])
+            [304, headers.dup, []]
+          else
+            files.call(static_request_env(env))
+          end
+        end
+      end
+
+      private
+
+      def static_request_env(env)
+        # If-None-Match takes precedence over If-Modified-Since.
+        ignore_modified_since = !@config.static_timestamps || (@config.static_etags && env.key?('HTTP_IF_NONE_MATCH'))
+        ignore_modified_since ? env.merge('HTTP_IF_MODIFIED_SINCE' => nil) : env
+      end
+
+      def static_headers(file)
+        headers = @config.static_etags ? { Rack::ETAG => %("#{Digest::SHA256.file(file).hexdigest}") } : {}
+        @config.static_cache_control ? headers.merge(Rack::CACHE_CONTROL => @config.static_cache_control) : headers
+      end
+
+      def matching_etag?(condition, etag)
+        condition.to_s.split(',').any? do |candidate|
+          candidate = candidate.strip.sub(%r{\AW/}, '')
+          candidate == '*' || candidate == etag
+        end
+      end
+    end
+
+    include StaticFiles
+
     def find_template_files(path_info)
       if m = path_info.match(@path_regex)
         @config.view_paths.inject([]) do |files, path|
@@ -66,7 +106,7 @@ module Rack
 
     def server_page(template)
       lambda do |env|
-        @binding.new(env).tap do |scope|
+        @binding.new(env, self).tap do |scope|
           catch(:halt) do
             begin
               @config.filter.invoke(scope, :before)
@@ -87,6 +127,36 @@ module Rack
       end
     end
 
+    module AssetPaths
+      def asset_path(path)
+        path, fragment = path.to_s.split('#', 2)
+        path, query = path.to_s.split('?', 2)
+        path, file = asset_file(path.to_s)
+        query = Rack::Utils.parse_query(query)
+        query['v'] = Digest::SHA256.file(file).hexdigest
+        "#{path}?#{Rack::Utils.build_query(query)}#{fragment && "##{fragment}"}"
+      end
+
+      private
+
+      def asset_file(path)
+        raise ArgumentError, 'asset_path requires a local asset path without parent-directory traversal' unless valid_asset_path?(CGI.unescape(path))
+
+        path = "#{@config.effective_path}/#{path.sub(%r{\A/}, '')}"
+        file = select_template_file(find_template_files(CGI.unescape(path)) || [])
+        raise Errno::ENOENT, path unless file && ::File.file?(file)
+
+        [path, file]
+      end
+
+      def valid_asset_path?(path)
+        !path.empty? && (path !~ %r{\A(?:[a-z][a-z0-9+.-]*:|//)}i) &&
+          !path.split('/').include?('..') && !path.include?("\0")
+      end
+    end
+
+    include AssetPaths
+
     class Filter
       TYPES = [:before, :after, :on_error].freeze
       TYPES.each do |type|
@@ -143,7 +213,8 @@ module Rack
         end
       end
 
-      hash_accessor :view_path, :effective_path, :cache_control, :default_charset, :failure_app, :show_exceptions
+      hash_accessor :view_path, :effective_path, :cache_control, :static_cache_control, :static_etags, :static_timestamps,
+                    :default_charset, :failure_app, :show_exceptions
 
       attr_reader :filter
 
@@ -153,6 +224,8 @@ module Rack
         super
         self[:default_charset] ||= 'utf-8'
         self[:view_path] ||= %w(views public)
+        self[:static_etags] = true
+        self[:static_timestamps] = true
         @helpers = []
         @filter  = Filter.new
       end
@@ -187,7 +260,7 @@ module Rack
         end
 
         def tilt?
-          @use_tilt.nil? ? (@use_tilt ||= !!defined?(Tilt)) : @use_tilt && defined?(Tilt)
+          @use_tilt != false && !!defined?(Tilt) && Tilt.respond_to?(:[])
         end
 
         def use_tilt(bool = true)
@@ -273,6 +346,10 @@ module Rack
     end
 
     module CoreHelper
+      def asset_path(path)
+        url(@server_pages.asset_path(path))
+      end
+
       def redirect(target, status = 302)
         response.redirect(target, status)
         halt
@@ -329,9 +406,10 @@ module Rack
         end
       end
 
-      def initialize(env)
+      def initialize(env, server_pages = nil)
         @request  = Rack::Request.new(env)
         @response = Rack::Response.new
+        @server_pages = server_pages
         # @response['Content-Type'] = nil
       end
 

data/lib/rack-server-pages/version.rb

@@ -1,5 +1,5 @@
 module Rack
   class ServerPages
-    VERSION = '0.2.1'.freeze
+    VERSION = '0.3.0'.freeze
   end
 end

data/rack-server-pages.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.summary     = 'Rack middleware and appilcation for serving dynamic pages.'
   s.description = 'Rack middleware and appilcation for serving dynamic pages in very simple way, without controllers or models, only views similar to ASP, JSP and PHP.'
 
-  s.files = Dir['lib/**/*', 'CHANGES.md', 'README.md', 'LICENSE.md', 'rack-server-pages.gemspec']
+  s.files = Dir['lib/**/*', 'CHANGES.md', 'README.md', 'UPGRADING.md', 'RELEASING.md', 'LICENSE.md', 'rack-server-pages.gemspec']
 
   s.require_paths = ['lib']
 

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-server-pages
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Masato Igarashi
 - Daniel Doubrovkine
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-31 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -36,6 +35,8 @@ files:
 - CHANGES.md
 - LICENSE.md
 - README.md
+- RELEASING.md
+- UPGRADING.md
 - lib/rack-server-pages.rb
 - lib/rack-server-pages/version.rb
 - lib/rack/server_pages.rb
@@ -44,7 +45,6 @@ homepage: http://github.com/migrs/rack-server-pages
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -59,8 +59,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Rack middleware and appilcation for serving dynamic pages.
 test_files: []