rack-spa 0.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f987e16a684d7095a44f36c3aa3c829d16f13a6d6eff194b3275a2a546941afc
+  data.tar.gz: dc4df61474e03ef8c60d80f72a3dace7c32b17105a3466dbaede1e95d9bfc62b
+SHA512:
+  metadata.gz: 8a31ce6bd3909f435824c945dce2f99037fa9acac5aca3dbd916bcbe61999c6bf93d2b0e47833217d37015980d50990cd88039ca85d0bd15074e535d1a1ea358
+  data.tar.gz: e62de5586131f91df9f0d5f52bcea43cc1cf525597448a8dd3f4904f342e82cddb3001094ddc13dea481022f89928f42fbb59ff6103cc34492bc4de45d6b3516

data/lib/rack/csp.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "rack"
+
+module Rack
+  class Csp
+    def initialize(app, policy:)
+      @app = app
+      @policy = policy
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers["Content-Security-Policy"] = @policy
+      [status, headers, body]
+    end
+  end
+end

data/lib/rack/dynamic_config_writer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "rack"
+require "nokogiri"
+require "json"
+
+# Allow dynamic configuration of a SPA.
+# When the backend app starts up, it should run #emplace.
+# This will 1) copy the index.html to a 'backup' location
+# if it does not exist, 2) replace a placeholder string
+# in the index.html with the given keys and values
+# (use .pick_env_vars to pull everything like 'REACT_APP_'),
+# and write it out to index.html.
+#
+# IMPORTANT: This sort of dynamic config writing is not normal
+# for SPAs so needs some further explanation.
+# The build process should be exactly the same;
+# for example, you'd still run `npm run build`,
+# and generate a totally normal build output.
+# It's the *backend* running that modifies index.html
+# (and creates index.html.original) *at backend startup*,
+# not at build time.
+module Rack
+  class DynamicConfigWriter
+    GLOBAL_ASSIGN = "window.rackDynamicConfig"
+    BACKUP_SUFFIX = ".original"
+
+    def initialize(
+      index_html_path,
+      global_assign: GLOBAL_ASSIGN,
+      backup_suffix: BACKUP_SUFFIX
+    )
+      @index_html_path = index_html_path
+      @global_assign = global_assign
+      @index_html_backup = index_html_path + backup_suffix
+    end
+
+    def emplace(keys_and_values)
+      self.prepare
+      json = JSON.generate(keys_and_values)
+      script = "#{@global_assign}=#{json}"
+      ::File.open(@index_html_backup) do |f|
+        doc = Nokogiri::HTML5(f)
+        doc.at("head").prepend_child("<script>#{script}</script>")
+        ::File.write(@index_html_path, doc.serialize)
+      end
+    end
+
+    protected def prepare
+      return if ::File.exist?(@index_html_backup)
+      ::FileUtils.move(@index_html_path, @index_html_backup)
+    end
+
+    def self.pick_env(regex_or_prefix)
+      return ENV.to_a.select { |(k, _v)| k.start_with?(regex_or_prefix) }.to_h if regex_or_prefix.is_a?(String)
+      return ENV.to_a.select { |(k, _v)| regex_or_prefix.match?(k) }.to_h
+    end
+  end
+end

data/lib/rack/immutable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rack"
+
+module Rack
+  class Immutable
+    # By default, match strings like 'main.abc123.js'.
+    # Assume the fingerprint is a Git SHA value of at least 6 characters,
+    # comes before the extension, and has some preceding segment of the path.
+    DEFAULT_MATCH = /.*\.[A-Za-z\d]{6}[A-Za-z\d]*\.[a-z]+/
+    IMMUTABLE = "public, max-age=604800, immutable"
+
+    def initialize(app, match: nil, cache_control: nil)
+      @app = app
+      @match = match || DEFAULT_MATCH
+      @cache_control = cache_control || IMMUTABLE
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers[Rack::CACHE_CONTROL] = @cache_control if
+        self._matches(env["PATH_INFO"], env)
+      return status, headers, body
+    end
+
+    def _matches(path, env)
+      return @match == path if @match.is_a?(String)
+      return @match.match?(path) if @match.is_a?(Regexp)
+      return @match.call(env)
+    end
+  end
+end

data/lib/rack/lambda_app.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rack"
+
+# Call the inner proc as the app.
+# If proc returns nil, keep calling middleware;
+# if proc returns a result, return it.
+module Rack
+  class LambdaApp
+    # LambdaApp.new returns itself, which has a +new+ method so it can
+    # be used like normal middleware.
+    def initialize(proc)
+      @proc = proc
+    end
+
+    def new(app)
+      @app = app
+      return self
+    end
+
+    def call(env)
+      result = @proc.call(env)
+      return result if result
+      return @app.call(env)
+    end
+  end
+end

data/lib/rack/remote_ip.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
+# This is based almost entirely on
+# https://github.com/rails/rails/blob/main/actionpack/lib/action_dispatch/middleware/remote_ip.rb
+# It hews as close to it as possible, while removign the dependency on ActionDispatch,
+# which we do not want/need. Unlike ActiveSupport, it is pretty tightly tied to Rails.
+#
+# ORIGINAL COMMENT
+#
+# This middleware calculates the IP address of the remote client that is
+# making the request. It does this by checking various headers that could
+# contain the address, and then picking the last-set address that is not
+# on the list of trusted IPs. This follows the precedent set by e.g.
+# {the Tomcat server}[https://issues.apache.org/bugzilla/show_bug.cgi?id=50453].
+# A more detailed explanation of the algorithm is given at GetIp#calculate_ip.
+#
+# Some Rack servers concatenate repeated headers, like {HTTP RFC 2616}[https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2]
+# requires. Some Rack servers simply drop preceding headers, and only report
+# the value that was {given in the last header}[https://andre.arko.net/2011/12/26/repeated-headers-and-ruby-web-servers].
+# If you are behind multiple proxy servers (like NGINX to HAProxy to Unicorn)
+# then you should test your Rack server to make sure your data is good.
+#
+# IF YOU DON'T USE A PROXY, THIS MAKES YOU VULNERABLE TO IP SPOOFING.
+# This middleware assumes that there is at least one proxy sitting around
+# and setting headers with the client's remote IP address. If you don't use
+# a proxy, because you are hosted on e.g. Heroku without SSL, any client can
+# claim to have any IP address by setting the +X-Forwarded-For+ header. If you
+# care about that, then you need to explicitly drop or ignore those headers
+# sometime before this middleware runs. Alternatively, remove this middleware
+# to avoid inadvertently relying on it.
+module Rack
+  class RemoteIp
+    class IpSpoofAttackError < StandardError; end
+
+    # The default trusted IPs list simply includes IP addresses that are
+    # guaranteed by the IP specification to be private addresses. Those will
+    # not be the ultimate client IP in production, and so are discarded. See
+    # https://en.wikipedia.org/wiki/Private_network for details.
+    TRUSTED_PROXIES = [
+      "127.0.0.0/8",    # localhost IPv4 range, per RFC-3330
+      "::1",            # localhost IPv6
+      "fc00::/7",       # private IPv6 range fc00::/7
+      "10.0.0.0/8",     # private IPv4 range 10.x.x.x
+      "172.16.0.0/12",  # private IPv4 range 172.16.0.0 .. 172.31.255.255
+      "192.168.0.0/16", # private IPv4 range 192.168.x.x
+    ].map { |proxy| IPAddr.new(proxy) }
+
+    attr_reader :check_ip, :proxies
+
+    # Create a new +RemoteIp+ middleware instance.
+    #
+    # The +skip_ip_spoofing_check+ option is off by default (so spoofing is enabled).
+    # When on, an exception
+    # is raised if it looks like the client is trying to lie about its own IP
+    # address. It makes sense to turn off this check on sites aimed at non-IP
+    # clients (like WAP devices), or behind proxies that set headers in an
+    # incorrect or confusing way (like AWS ELB).
+    #
+    # The +custom_proxies+ argument can take an enumerable which will be used
+    # instead of +TRUSTED_PROXIES+. Any proxy setup will put the value you
+    # want in the middle (or at the beginning) of the +X-Forwarded-For+ list,
+    # with your proxy servers after it. If your proxies aren't removed, pass
+    # them in via the +custom_proxies+ parameter. That way, the middleware will
+    # ignore those IP addresses, and return the one that you want.
+    def initialize(app, skip_ip_spoofing_check: false, custom_proxies: [])
+      @app = app
+      @check_ip = !skip_ip_spoofing_check
+      @proxies = TRUSTED_PROXIES + custom_proxies
+    end
+
+    # Since the IP address may not be needed, we store the object here
+    # without calculating the IP to keep from slowing down the majority of
+    # requests. For those requests that do need to know the IP, the
+    # GetIp#calculate_ip method will calculate the memoized client IP address.
+    def call(env)
+      env["remote_ip"] = GetIp.new(env, self.check_ip, self.proxies)
+      @app.call(env)
+    end
+
+    # The GetIp class exists as a way to defer processing of the request data
+    # into an actual IP address. If env['remote_ip'].to_s is called,
+    # this class will calculate the value and then memoize it.
+    class GetIp
+      def initialize(env, check_ip, proxies)
+        @env      = env
+        @check_ip = check_ip
+        @proxies  = proxies
+      end
+
+      def remote_addr = @remote_addr ||= @env["REMOTE_ADDR"]
+      def client_ip = @client_ip ||= @env["HTTP_CLIENT_IP"]
+      def x_forwarded_for = @x_forwarded_for ||= @env["HTTP_X_FORWARDED_FOR"]
+
+      # Sort through the various IP address headers, looking for the IP most
+      # likely to be the address of the actual remote client making this
+      # request.
+      #
+      # REMOTE_ADDR will be correct if the request is made directly against the
+      # Ruby process, on e.g. Heroku. When the request is proxied by another
+      # server like HAProxy or NGINX, the IP address that made the original
+      # request will be put in an +X-Forwarded-For+ header. If there are multiple
+      # proxies, that header may contain a list of IPs. Other proxy services
+      # set the +Client-Ip+ header instead, so we check that too.
+      #
+      # As discussed in {this post about Rails IP Spoofing}[https://blog.gingerlime.com/2012/rails-ip-spoofing-vulnerabilities-and-protection/],
+      # while the first IP in the list is likely to be the "originating" IP,
+      # it could also have been set by the client maliciously.
+      #
+      # In order to find the first address that is (probably) accurate, we
+      # take the list of IPs, remove known and trusted proxies, and then take
+      # the last address left, which was presumably set by one of those proxies.
+      def calculate_ip
+        # Set by the Rack web server, this is a single value.
+        remote_addr = ips_from(self.remote_addr).last
+
+        # Could be a CSV list and/or repeated headers that were concatenated.
+        client_ips    = ips_from(self.client_ip).reverse
+        forwarded_ips = ips_from(self.x_forwarded_for).reverse
+
+        # +Client-Ip+ and +X-Forwarded-For+ should not, generally, both be set.
+        # If they are both set, it means that either:
+        #
+        # 1) This request passed through two proxies with incompatible IP header
+        #    conventions.
+        # 2) The client passed one of +Client-Ip+ or +X-Forwarded-For+
+        #    (whichever the proxy servers weren't using) themselves.
+        #
+        # Either way, there is no way for us to determine which header is the
+        # right one after the fact. Since we have no idea, if we are concerned
+        # about IP spoofing we need to give up and explode. (If you're not
+        # concerned about IP spoofing you can turn the +ip_spoofing_check+
+        # option off.)
+        should_check_ip = @check_ip && client_ips.last && forwarded_ips.last
+        if should_check_ip && !forwarded_ips.include?(client_ips.last)
+          # We don't know which came from the proxy, and which from the user
+          raise IpSpoofAttackError, "IP spoofing attack?! " \
+                                    "HTTP_CLIENT_IP=#{env['HTTP_CLIENT_IP'].inspect} " \
+                                    "HTTP_X_FORWARDED_FOR=#{env['HTTP_X_FORWARDED_FOR'].inspect}"
+        end
+
+        # We assume these things about the IP headers:
+        #
+        #   - X-Forwarded-For will be a list of IPs, one per proxy, or blank
+        #   - Client-Ip is propagated from the outermost proxy, or is blank
+        #   - REMOTE_ADDR will be the IP that made the request to Rack
+        ips = [forwarded_ips, client_ips].flatten.compact
+
+        # If every single IP option is in the trusted list, return the IP
+        # that's furthest away
+        filter_proxies(ips + [remote_addr]).first || ips.last || remote_addr
+      end
+
+      # Memoizes the value returned by #calculate_ip and returns it for
+      # ActionDispatch::Request to use.
+      def to_s
+        return @to_s ||= self.calculate_ip
+      end
+
+      private def ips_from(header)
+        return [] unless header
+        # Split the comma-separated list into an array of strings.
+        ips = header.strip.split(/[,\s]+/)
+        ips.select do |ip|
+          # Only return IPs that are valid according to the IPAddr#new method.
+          range = IPAddr.new(ip).to_range
+          # We want to make sure nobody is sneaking a netmask in.
+          range.begin == range.end
+        rescue ArgumentError
+          nil
+        end
+      end
+
+      private def filter_proxies(ips)
+        ips.reject do |ip|
+          @proxies.any? { |proxy| proxy === ip }
+        end
+      end
+    end
+  end
+end

data/lib/rack/service_worker_allowed.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rack"
+
+# Set the Service-Worker-Allowed header to the given scope
+# if this is a service worker request.
+module Rack
+  class ServiceWorkerAllowed
+    def initialize(app, scope:)
+      @app = app
+      @scope = scope
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers["Service-Worker-Allowed"] = @scope if env["HTTP_SERVICE_WORKER"]
+      return status, headers, body
+    end
+  end
+end

data/lib/rack/simple_redirect.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "rack"
+
+# Redirect a request based on the route it matches.
+module Rack
+  class SimpleRedirect
+    # The keys in +routes+ can be strings, regular expressions, or callables.
+    # For a key that matches (using == for strings, .match?(path) for regexes,
+    # or call(env) for callables), the Location in the redirect
+    # is equal to the value of the key, or if the value is a callable,
+    # the returned result of calling the value with env.
+    def initialize(app, routes: {}, status: 302)
+      @app = app
+      @routes = routes
+      @status = status
+    end
+
+    def call(env)
+      path = env["PATH_INFO"]
+      loc = nil
+      @routes.each do |route, result|
+        if self._matches(path, env, route)
+          loc = result.respond_to?(:call) ? result[env] : result
+          break
+        end
+      end
+      return @app.call(env) if loc.nil?
+      return [@status, {"Location" => loc}, []]
+    end
+
+    def _matches(path, env, route)
+      return route == path if route.is_a?(String)
+      return route.match?(path) if route.is_a?(Regexp)
+      return route.call(env)
+    end
+
+    def _check_routes_opts(h)
+      h.each do |k, v|
+        case k
+          when String, Regexp, Proc
+            nil
+          else
+            raise "SimpleRedirect routes keys must be strings, regexes, or procs"
+        end
+        case v
+          when String, Proc
+            nil
+          else
+            raise "SimpleRedirect routes values must be strings or procs"
+        end
+      end
+    end
+  end
+end

data/lib/rack/spa_app.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "rack/immutable"
+require "rack/lambda_app"
+require "rack/simple_redirect"
+require "rack/spa_rewrite"
+
+module Rack
+  class SpaApp
+    def self.dependencies(build_folder, immutable: true, enforce_ssl: true, service_worker_allowed: nil)
+      result = []
+      result << [Rack::SslEnforcer, {redirect_html: false}] if enforce_ssl
+      result << [Rack::ConditionalGet, {}]
+      result << [Rack::ETag, {}]
+      result << [Rack::Immutable, {match: immutable.is_a?(TrueClass) ? nil : immutable}] if immutable
+      result << [Rack::SpaRewrite, {index_path: "#{build_folder}/index.html", html_only: true}]
+      result << [Rack::ServiceWorkerAllowed, {scope: service_worker_allowed}] if service_worker_allowed
+      result << [Rack::Static, {urls: [""], root: build_folder.to_s, cascade: true}]
+      result << [Rack::SpaRewrite, {index_path: "#{build_folder}/index.html", html_only: false}]
+      return result
+    end
+
+    def self.install(builder, dependencies)
+      dependencies.each { |cls, opts| builder.use(cls, **opts) }
+    end
+
+    def self.run(builder)
+      builder.run Rack::LambdaApp.new(->(_) { raise "Should not see SpaApp fallback" })
+    end
+
+    def self.run_spa_app(builder, build_folder, enforce_ssl: true, immutable: true, **kw)
+      deps = self.dependencies(build_folder, enforce_ssl:, immutable:, **kw)
+      self.install(builder, deps)
+      self.run(builder)
+    end
+  end
+end

data/lib/rack/spa_rewrite.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "rack"
+
+module Rack
+  class SpaRewrite
+    ALLOWED_VERBS = ["GET", "HEAD", "OPTIONS"].freeze
+    ALLOW_HEADER = ALLOWED_VERBS.join(", ")
+
+    def initialize(app, index_path:, html_only:)
+      @app = app
+      @index_path = index_path
+      @html_only = html_only
+      begin
+        @index_mtime = ::File.mtime(@index_path).httpdate
+      rescue Errno::ENOENT
+        @index_mtime = Time.at(0)
+      end
+      @index_bytes = nil
+      @head = Rack::Head.new(->(env) { get env })
+    end
+
+    def call(env)
+      # HEAD requests drop the response body, including 4xx error messages.
+      @head.call env
+    end
+
+    def get(env)
+      request = Rack::Request.new env
+      return @app.call(env) if @html_only && !request.path_info.end_with?(".html")
+      return [405, {"Allow" => ALLOW_HEADER}, ["Method Not Allowed"]] unless
+        ALLOWED_VERBS.include?(request.request_method)
+
+      path_info = Rack::Utils.unescape_path(request.path_info)
+      return [400, {}, ["Bad Request"]] unless Rack::Utils.valid_path?(path_info)
+
+      return [200, {"Allow" => ALLOW_HEADER, Rack::CONTENT_LENGTH => "0"}, []] if
+        request.options?
+
+      lastmod = ::File.mtime(@index_path)
+      lastmodhttp = lastmod.httpdate
+      return [304, {}, []] if request.get_header("HTTP_IF_MODIFIED_SINCE") == lastmodhttp
+
+      @index_bytes = ::File.read(@index_path) if @index_bytes.nil? || @index_mtime < lastmodhttp
+      headers = {
+        "content-length" => @index_bytes.bytesize.to_s,
+        "content-type" => "text/html",
+        "last-modified" => lastmodhttp,
+      }
+      return [200, headers, [@index_bytes]]
+    end
+  end
+end

data/lib/rack_spa.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RackSpa
+  VERSION = "0.10.0"
+end

metadata

@@ -0,0 +1,203 @@
+--- !ruby/object:Gem::Specification
+name: rack-spa
+version: !ruby/object:Gem::Version
+  version: 0.10.0
+platform: ruby
+authors:
+- Lithic Tech
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-03-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rackup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rspec-temp_dir
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.25.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.25.1
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.3
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 'Rack middlewares to make building and serving a Single Page App from
+  a Ruby Rack app easy.
+
+  '
+email: hello@lithic.tech
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rack/csp.rb
+- lib/rack/dynamic_config_writer.rb
+- lib/rack/immutable.rb
+- lib/rack/lambda_app.rb
+- lib/rack/remote_ip.rb
+- lib/rack/service_worker_allowed.rb
+- lib/rack/simple_redirect.rb
+- lib/rack/spa_app.rb
+- lib/rack/spa_rewrite.rb
+- lib/rack_spa.rb
+homepage: https://github.com/lithictech/rack-spa
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Rack middlewares to make building and serving a Single Page App from a Ruby
+  Rack app easy.
+test_files: []