coldwire-rails 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 268be717f39cc2dcb3927c27c22256afcc81981facc029f9be277ef9c22c1ee0
-  data.tar.gz: 03cc56cf120523536b582180dcb8366fc9194ca3ada5dca136abd44761cf7afb
+  metadata.gz: e48a15a424535143cc620dbbe65eec4a367c9e1feaa60addc104587ee835c836
+  data.tar.gz: b85fc7cfc8b80db94b14e994afbb258cc997d0b161986738e80c33a8a49704d5
 SHA512:
-  metadata.gz: d2bf7e4ef38d0b7f3e25483995663263468f092904810a9aa48186c0dff1abfd5429890ff0aadc628fd14730d287da327e05daac39d07d92f0c66507f10fc4a2
-  data.tar.gz: edea984f52957b16f2fd2f0664c9bcf262cf58735679b646b6c345730a4df65524f36e3a4fa3a8ff32ed17a697f0b030330ee670ac860a3fc0f3d06d6aefa120
+  metadata.gz: 543c39e2d9999a45ce8041d4c87cb2853908056611bdc189d49e0fde87309373260131f433f92715d29943fcd44eb1d429aa6f270ef639287c0d45ce86787f11
+  data.tar.gz: 31bc9a01f008bd987c79700058b49682cae9d1020e873bf9aab03949fe9d15d9619c420c7b5c9efe7032a6b07eddaa090b54d43adecd9cf2f503983d4e702632

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [Unreleased]
+
+## [0.3.0]
+
+- **`cache_origins` is `cacheable_hosts`**, and takes bare hosts: `"tiles.example.com"` rather
+  than `"https://tiles.example.com"`. The scheme was never carrying information — a worker
+  runs only on a secure page, and a secure page cannot fetch `http` — so it was a required
+  prefix with exactly one possible value. Requests are matched on a URL's `host`, so a port
+  belongs where it is not the default and `localhost:3001` matches that port and no other.
+  A scheme raises at boot, naming what to write instead.
+
+## [0.2.0]
+
+- **Garbage collection** is on by default. `config.garbage_collection` periodically sweeps the cache, deleting entries that haven't been accessed for `max_age` (default: 60 days), and if the cache grows over `max_size` (default: 250 MB), it continues pruning the least recently accessed until the cache fits. Sweeps run only when confirmed online by pinging `probe_path`, since deletions are irreversible. Cached archives and offline page assets are never collected, and the age of an entry is renewed anytime it or its referenced subresources are accessed or stored. The size ceiling can be adjusted in the offline settings page and is remembered per device.
+- The garbage collector runs safely and automatically; you generally do not need to configure it. But you can tune `max_age`, `max_size`, and `interval` to fit your app's needs.
+
+
 ## [0.1.0]
 
 First release. The API may still change before 1.0.

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/app/views/coldwire/service_worker/show.js.erb

@@ -21,7 +21,7 @@ const CACHE_AS_YOU_GO = compileRules(<%= raw Coldwire.cache_rules(Coldwire.confi
 const NEVER_CACHE = compileRules(<%= raw Coldwire.cache_rules(Coldwire.config.never_cache).to_json %>)
 // Origins besides ours that may be cached at all, and the URLs whose byte ranges are cached
 // piece by piece.
-const CACHE_ORIGINS = <%= raw Coldwire.config.cache_origins.to_json %>
+const CACHEABLE_HOSTS = <%= raw Coldwire.config.cacheable_hosts.to_json %>
 const CACHE_RANGES = compileRules(<%= raw Coldwire.cache_rules(Coldwire.config.cache_ranges).to_json %>)
 // A range entry is stored under its own key, with the range in the query and the archive's
 // total size in a header — the two things needed to rebuild a 206 that was never storable.

data/docs/configuration.md

@@ -36,7 +36,7 @@ Coldwire.configure do |config|
   config.never_cache = []
   config.never_intercept = [ "/up" ]
 
-  config.cache_origins = []
+  config.cacheable_hosts = []
   config.cache_ranges = []
   config.cache_archives = []
 
@@ -71,7 +71,7 @@ down with it.
 | [`cache_as_you_go`](#cache_as_you_go) | `["/*"]` | Pages stored as somebody browses. `/*` is everything |
 | [`never_cache`](#never_cache) | `[]` | Never stored, by any route in. The one veto |
 | [`never_intercept`](#never_intercept) | `["/up"]` | Paths the worker does not touch at all |
-| [`cache_origins`](#cache_origins) | `[]` | Other origins the worker may cache |
+| [`cacheable_hosts`](#cacheable_hosts) | `[]` | Other hosts the worker may cache |
 | [`cache_ranges`](#cache_ranges) | `[]` | URLs whose `Range` requests are cached piece by piece |
 | [`cache_archives`](#cache_archives) | `[]` | Large files somebody can choose to download |
 | [`ignore_query_params`](#ignore_query_params) | `true` | Treat `/map` and `/map?zoom=9` as one page |
@@ -497,22 +497,28 @@ config.never_cache = [ %r{^/admin(/|$)}, %r{^/users/[^/]+/edit$} ]
 
 ---
 
-## `cache_origins`
+## `cacheable_hosts`
 
 **Default:** `[]`
 
-Origins besides your own that the worker may cache. Each has to send CORS headers naming
-your app, or the response arrives opaque — status 0, no headers, no readable body — and
-there is nothing worth storing. Ranged sources must also expose `Content-Range`.
+The hosts besides your own that the worker may cache. Each has to send CORS headers naming
+your app, or the response arrives opaque — status 0, no headers, no readable body — and there
+is nothing worth storing. Ranged sources must also expose `Content-Range`.
 
 ```ruby
-config.cache_origins = [ "https://tiles.example.com" ]
+config.cacheable_hosts = [ "tiles.example.com", "localhost:3001" ]
 ```
 
-Bare origins only: a scheme and a host, no path, no trailing slash. Anything else raises at
-boot, because a malformed origin silently fails to match a request's origin.
+Just the host. No scheme: a worker runs only on a secure page, and a secure page cannot fetch
+`http`, so there was never a second scheme for one to tell apart. Writing one raises at boot
+rather than being stripped — a scheme quietly accepted is a config that looks migrated and is
+not, and the error names what to write instead.
 
-Cross-origin requests are passed through unless the origin is listed here.
+A port only where it is not the default. A request is matched on its URL's `host`, against
+exactly what you wrote: `localhost:3001` matches that port and no other, and a subdomain is a
+different host.
+
+Requests to anywhere else are passed straight through — not intercepted, not stored.
 
 ---
 
@@ -530,7 +536,7 @@ config.cache_ranges = [ "/tiles/*", %r{\.pmtiles$} ]
 
 Patterns match the URL path, same as the other lists — not the full URL. A cross-origin
 tile at `https://tiles.example.com/basemap.pmtiles` is allowed only when that origin is in
-[`cache_origins`](#cache_origins) *and* its path matches a rule here.
+[`cacheable_hosts`](#cacheable_hosts) *and* its path matches a rule here.
 
 This pairs with [`cache_archives`](#cache_archives): `cache_ranges` caches the slices
 actually read, so the places you have already opened work offline, and downloading the
@@ -561,7 +567,7 @@ Files arrive in 8 MB chunks, which is what makes a dropped connection cost secon
 of the whole download. A `Range` request against a downloaded archive is answered by
 slicing the chunks.
 
-If the file lives on another origin, list that origin in [`cache_origins`](#cache_origins).
+If the file lives on another host, list it in [`cacheable_hosts`](#cacheable_hosts).
 
 ---
 

data/docs/setup.md

@@ -176,7 +176,7 @@ app-bound mode and takes service workers with it.
 ## Optional next steps
 
 - Restrict what browsing stores with [`cache_as_you_go`](configuration.md#cache_as_you_go)
-- Nominate other origins or `Range` URLs with [`cache_origins`](configuration.md#cache_origins)
+- Nominate other hosts or `Range` URLs with [`cacheable_hosts`](configuration.md#cacheable_hosts)
   and [`cache_ranges`](configuration.md#cache_ranges)
 - Offer large files for download with [`cache_archives`](configuration.md#cache_archives)
 - Override the offline fallback by creating

data/lib/coldwire/configuration.rb

@@ -88,13 +88,19 @@ module Coldwire
     # cached pages hold whatever the previous session could see.
     attr_writer :cache_identity
 
-    # Origins besides your own that the worker may cache. Each has to send CORS headers naming
+    # The hosts besides your own that the worker may cache. Each has to send CORS headers naming
     # your app, or the response arrives opaque — status 0, no headers, no readable body — and
     # there is nothing worth storing. Ranged sources must also expose Content-Range.
-    attr_reader :cache_origins
+    #
+    #   config.cacheable_hosts = [ "tiles.example.com" ]
+    #
+    # A hostname, with a port only where it is not the default — which is what a URL's `host`
+    # reads as. No scheme: a worker runs only on a secure page, and a secure page cannot fetch
+    # http, so there was never a second scheme for one to tell apart.
+    attr_reader :cacheable_hosts
 
-    def cache_origins=(origins)
-      @cache_origins = Array(origins).map { |origin| validate_origin(origin) }
+    def cacheable_hosts=(hosts)
+      @cacheable_hosts = Array(hosts).map { |host| validate_host(host) }
     end
 
     # URLs whose Range requests are cached piece by piece, keyed by the range — for a large
@@ -278,7 +284,7 @@ module Coldwire
       @register_if = -> { true }
       @caching_enabled_by_default = true
       @cache_identity = -> { nil }
-      @cache_origins = []
+      @cacheable_hosts = []
       @cache_ranges = []
       @cache_archives = []
     end
@@ -330,19 +336,27 @@ module Coldwire
 
     # An origin and nothing more: no path, no trailing slash. Anything else silently fails to
     # match a request's origin, which is the same quiet failure as a malformed path pattern.
-    def validate_origin(origin)
-      value = origin.to_s
-
-      begin
-        uri = URI.parse(value)
-      rescue URI::InvalidURIError
-        uri = nil
+    # A host, and a port only where it is not the default — which is exactly what a URL's
+    # `host` reads as, so the worker compares what you wrote against what it is handed.
+    HOST = /\A[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)*(?::\d+)?\z/
+    SCHEME = %r{\A[a-z][a-z0-9+.\-]*://}
+
+    # Raised rather than quietly stripped. Everyone arriving here is renaming `cache_origins`,
+    # and a scheme silently accepted is a config that looks migrated and is not — the next
+    # person to read it learns the wrong shape.
+    def validate_host(host)
+      value = host.to_s.strip.downcase
+
+      if value.match?(SCHEME)
+        raise ArgumentError,
+              "Coldwire cacheable_hosts takes a host with no scheme — " \
+              "#{value.sub(SCHEME, '').chomp('/').inspect} rather than #{host.inspect}"
       end
 
-      unless uri&.scheme && uri.host && uri.path.to_s.empty? && uri.query.nil?
+      unless value.match?(HOST)
         raise ArgumentError,
-              "Coldwire cache_origins takes bare origins like " \
-              "\"https://tiles.example.com\": #{origin.inspect}"
+              "Coldwire cacheable_hosts takes bare hosts like " \
+              "\"tiles.example.com\": #{host.inspect}"
       end
 
       value

data/lib/coldwire/worker/rules.js

@@ -3,7 +3,7 @@ function shouldHandle(request) {
   if (request.method !== "GET") return false
 
   const url = new URL(request.url)
-  if (!cacheableOrigin(url)) return false
+  if (!cacheableHost(url)) return false
 
   // A Range request cannot be stored as it arrives — cache.put refuses a 206 — so it is
   // stored as a 200 under a key naming the range, and answered with a 206 built here. Only
@@ -16,8 +16,8 @@ function shouldHandle(request) {
 
 // Our own origin, plus any the host app has nominated. A worker sees every request a page
 // makes, and caching other people's responses uninvited is not its business.
-function cacheableOrigin(url) {
-  return url.origin === self.location.origin || CACHE_ORIGINS.includes(url.origin)
+function cacheableHost(url) {
+  return url.origin === self.location.origin || CACHEABLE_HOSTS.includes(url.host)
 }
 
 function matchesPath(url, paths) {
@@ -83,7 +83,7 @@ function isAutoCacheable(request) {
 
   // A nominated origin is the opt-in; the path lists describe this app's own surfaces and say
   // nothing useful about somebody else's.
-  if (url.origin !== self.location.origin) return CACHE_ORIGINS.includes(url.origin)
+  if (url.origin !== self.location.origin) return CACHEABLE_HOSTS.includes(url.host)
 
   if (isNeverCached(url)) return false
 

data/lib/coldwire/worker/serve.js

@@ -43,7 +43,7 @@ function urlsFromHtml(html, pageUrl) {
         // Any origin we are allowed to cache, not just our own. A page whose map library
         // comes off a CDN is not offline-ready without it: precaching the page and skipping
         // the script it cannot run without leaves a blank screen and a full cache.
-        if (!cacheableOrigin(url)) return
+        if (!cacheableHost(url)) return
         if (matchesPath(url, NEVER_INTERCEPT)) return
         urls.add(url.href)
       } catch {}

data/lib/generators/coldwire/install/templates/coldwire.rb

@@ -54,8 +54,9 @@ Coldwire.configure do |config|
   # Never intercepted, so these fail outright offline. Coldwire's own routes are added for you.
   config.never_intercept = [ "/up" ]  # probe_path is added for you
 
-  # Origins besides your own the worker may cache, and URLs whose Range requests it caches.
-  config.cache_origins = []
+  # The hosts besides your own the worker may cache, and URLs whose Range requests it caches.
+  # No scheme — "tiles.example.com" — and a port only where it is not the default.
+  config.cacheable_hosts = []
   config.cache_ranges = []
 
   # Large files somebody can download for offline use. Nothing downloads on its own.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coldwire-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Noreaster Group, Stuart Yamartino