static-rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9a555d5b5ad757f03beff3a2b8e25b4abebdb3e9446d6089017c02b11450bc4a
+  data.tar.gz: 4b48dff937b530a8d407d312091b80649dbc0a4522457dc022eba8ebb8926af7
+SHA512:
+  metadata.gz: c789c382631f82888708250d75cbf7a541bb344a46706699903fe267e957ced8f20b5bf4ff24e27171eaf2c6fb3d2ef82e81cb7ce0044a5fc7abb99f92b960f8
+  data.tar.gz: 41dcfb55228d18933242c3c2aef24cbbcccd6cd0508ce10a97f2c0a3849db03aa81d099efd43f571fd57bd77220aabd6fc176ab8c7188f29ad9eafcb1b6642fd

data/.circleci/config.yml

@@ -0,0 +1,63 @@
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.7-node-browsers
+        environment:
+          RUBYOPT: "-W:no-deprecated -W:no-experimental"
+    steps:
+      - checkout
+
+      - run:
+        name: Add fake blog to the host
+        command: echo 127.0.0.1 blog.localhost | sudo tee -a /etc/hosts
+
+      # One of the apps needs hugo
+      - run: apt-get update && apt-get install -y --no-install-recommends hugo
+
+      # Bundle install dependencies
+      - type: cache-restore
+        key: v1-main-{{ checksum "Gemfile.lock" }}
+
+      - run: gem install bundler --version `tail -1 Gemfile.lock`
+      - run: bundle install --path vendor/bundle
+
+      - type: cache-save
+        key: v1-main-{{ checksum "Gemfile.lock" }}
+        paths:
+          - vendor/bundle
+
+      # Bundle install dependencies for example app
+      - type: cache-restore
+        key: v1-example-{{ checksum "example/Gemfile.lock" }}
+
+      - run: |
+          cd example
+          bundle install --path vendor/bundle
+
+      - type: cache-save
+        key: v1-example-{{ checksum "example/Gemfile.lock" }}
+        paths:
+          - example/vendor/bundle
+
+      # Yarn dependencies
+      - restore_cache:
+          keys:
+            - v2-yarn-{{ checksum "example/yarn.lock" }}
+            # fallback to using the latest cache if no exact match is found
+            - v2-yarn-
+
+      - run: |
+          cd example
+          yarn install
+
+      - save_cache:
+          paths:
+            - example/node_modules
+            - ~/.cache
+          key: v2-yarn-{{ checksum "example/yarn.lock" }}
+
+      - run: bin/rake standard:fix
+      - run: |
+        cd example
+        ./script/test

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.standard.yml

@@ -0,0 +1,5 @@
+ignore:
+  - example/**/*
+  - node_modules/**/*
+  - vendor/**/*
+

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.7.0
+before_install: gem install bundler -v 2.1.4

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake", "~> 13.0"
+gem "minitest", "~> 5.0"
+gem "standard"

data/Gemfile.lock

@@ -0,0 +1,99 @@
+PATH
+  remote: .
+  specs:
+    static-rails (0.0.1)
+      rack-proxy (~> 0.6)
+      railties (>= 5.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (6.0.2.2)
+      actionview (= 6.0.2.2)
+      activesupport (= 6.0.2.2)
+      rack (~> 2.0, >= 2.0.8)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actionview (6.0.2.2)
+      activesupport (= 6.0.2.2)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activesupport (6.0.2.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2)
+    ast (2.4.0)
+    builder (3.2.4)
+    concurrent-ruby (1.1.6)
+    crass (1.0.6)
+    erubi (1.9.0)
+    i18n (1.8.2)
+      concurrent-ruby (~> 1.0)
+    jaro_winkler (1.5.4)
+    loofah (2.5.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    method_source (1.0.0)
+    mini_portile2 (2.4.0)
+    minitest (5.14.0)
+    nokogiri (1.10.9)
+      mini_portile2 (~> 2.4.0)
+    parallel (1.19.1)
+    parser (2.7.1.1)
+      ast (~> 2.4.0)
+    rack (2.2.2)
+    rack-proxy (0.6.5)
+      rack
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.3.0)
+      loofah (~> 2.3)
+    railties (6.0.2.2)
+      actionpack (= 6.0.2.2)
+      activesupport (= 6.0.2.2)
+      method_source
+      rake (>= 0.8.7)
+      thor (>= 0.20.3, < 2.0)
+    rainbow (3.0.0)
+    rake (13.0.1)
+    rexml (3.2.4)
+    rubocop (0.80.1)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.7.0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      rexml
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 1.7)
+    rubocop-performance (1.5.2)
+      rubocop (>= 0.71.0)
+    ruby-progressbar (1.10.1)
+    standard (0.2.5)
+      rubocop (~> 0.80.1)
+      rubocop-performance (~> 1.5.2)
+    thor (1.0.1)
+    thread_safe (0.3.6)
+    tzinfo (1.2.7)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.6.1)
+    zeitwerk (2.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest (~> 5.0)
+  rake (~> 13.0)
+  standard
+  static-rails!
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Test Double, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,162 @@
+# static-rails
+
+A gem to support integrating one or more static sites with your Rails
+application.
+
+## Install
+
+Add this to the Gemfile of your Rails app:
+
+```
+gem "static-rails"
+```
+
+And run this to generate an initializer in which to configure your static sites:
+
+```
+$ rails g static_rails:initializer
+```
+
+This will create an documented configuration file in
+`config/initializers/static.rb`
+
+Once installed, any `config.sites` you specify will be handled by static-rails
+in the following way, by default:
+
+* In `development` and `test`, static-rails will start each site's
+  `serve_command` and proxy any requests to the Rails server that match the
+  `url_subdomain` and `url_root_path` to that server
+
+* When running `rake assets:precompile` (typically performed during a deploy),
+  static-rails will run the `compile_command` for each configured site
+
+* In `production`, static-rails will use `Rack::Static` to map any requests to
+  the Rails server that match the site's `url_subdomain` and `url_root_path`
+  settings (note that this is the opposite default for Rails'
+  `config.public_file_server.enabled` setting, which is disabled by default)
+
+For examples on how to configure your static site, read on!
+
+## Configuring your static site generators
+
+### Using Jekyll
+
+If you have a Jekyll app that you plan on serving from a non-root path (say,
+`/docs`), then you'll need to set the `baseurl` in `_config.yml`:
+
+```yml
+baseurl: "/docs"
+```
+
+(Note that this means running the Jekyll application directly using `bundle exec
+jekyll serve` will also start serving at `http://127.0.0.1:4000/docs/`)
+
+### Using Hugo
+
+If you are mounting your [Hugo](https://gohugo.io) app to anything but the root
+path, you'll need to specify that path in the `baseURL` of your root
+`config.toml` file, like so:
+
+```toml
+baseURL = "http://blog.example.com/docs"
+```
+
+Additionally, getting Hugo to play nicely when being proxied by your Rails
+server in development and test can be a little tricky, because most themes will
+render fully-qualified URLs into markup when running the `hugo server` command.
+That means if you're forwarding `http://blog.localhost:3000/docs` to a Hugo
+server running on `http://localhost:1313`, it's very likely the static files
+(e.g. all the links on the page) will have references to
+`http://localhost:1313`, which may result in accidentally navigating away from
+your Rails development server unexpectedly.
+
+To mitigate this, there are a few things you can do:
+
+* Favor `.RelPermalink` in your templates over `.Permalink` where possible.
+* In place of referring to `{{.Site.BaseURL}}` in your templates, generate a
+  base path with `{{ "/" | relURL }}` (given the above `baseURL`, this will
+  render `"/marketing/"`)
+
+Also, because Hugo will serve `/livereload.js` from the root, it probably won't
+work in development when running through the static-rails proxy in development.
+You might consider disabling it with `--disableLiveReload`.
+
+A static-rails config for a Hugo configuration in `sites` might look like:
+
+```rb
+  {
+    name: "docs",
+    url_root_path: "/docs",
+    source_dir: "static/docs",
+    server_command: "hugo server",
+    server_port: 8080,
+    compile_command: "hugo",
+    compile_dir: "static/docs/public"
+  }
+```
+
+### Using Eleventy
+
+If you are mounting your [Eleventy](https://www.11ty.dev) app to anything but
+the root path, you'll want to configure a path prefix in `.eleventy.js`
+
+```js
+module.exports = {
+  pathPrefix: "/docs/"
+}
+```
+
+Alternatively, you can specify this from the command line with `--pathprefix
+/docs`.
+
+A static-rails config for an Eleventy configuration in `sites` might look like:
+
+```rb
+  {
+    name: "docs",
+    url_root_path: "/docs",
+    source_dir: "static/docs",
+    server_command: "npx @11ty/eleventy --serve --pathprefix /docs",
+    server_port: 8080,
+    compile_command: "npx @11ty/eleventy --pathprefix /docs",
+    compile_dir: "static/docs/_site"
+  }
+```
+
+### Using Gatsby
+
+** ⚠️ Gatsby is unlikely to work in development mode, due to [this
+issue](https://github.com/gatsbyjs/gatsby/issues/18143), wherein all the assets
+are actually served over a socket.io WebSocket channel and not able to be
+proxied effectively. ⚠️  **
+
+If you're mounting a [Gatsby](https://www.gatsbyjs.org) site to a non-root path
+(e.g. in static-rails, you've configured its `url_root_path` to, say,
+`careers`), then you'll want to configure the same root path in Gatsby as well,
+so that its development servers and built assets line up correctly.
+
+To do this, first add the `pathPrefix` property to `gatsby-config.js`:
+
+```js
+module.exports = {
+  pathPrefix: `/careers`,
+  // …
+}
+```
+
+Next, add the flag `--prefix-paths` to both the Gatsby site's `server_command`
+and `compile_command`, or else the setting will be ignored.
+
+A static-rails config for a Gatsby configuration in `sites` might look like:
+
+```rb
+  {
+    name: "gatsby",
+    url_root_path: "/docs",
+    source_dir: "static/docs",
+    server_command: "npx gatsby develop --prefix-paths",
+    server_port: 8000,
+    compile_command: "npx gatsby build --prefix-paths",
+    compile_dir: "static/docs/public"
+  },
+```

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "standard/rake"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: ["standard:fix", :test]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rails/static/site"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/generators/static_rails/initializer_generator.rb

@@ -0,0 +1,12 @@
+module StaticRails
+  module Generators
+    class InitializerGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+
+      desc "Creates a sample static-rails initializer."
+      def copy_initializer
+        copy_file "static.rb", "config/initializers/static.rb"
+      end
+    end
+  end
+end

data/lib/generators/templates/static.rb

@@ -0,0 +1,55 @@
+StaticRails.config do |config|
+  # Control whether static-rails adds a middleware to proxy requests to your static site servers
+  # config.proxy_requests = !Rails.env.production?
+
+  # Control whether static-rails adds a middleware to serve your sites' compiled static assets with Static::Rack (has no effect if proxy_requests is enabled)
+  # config.serve_compiled_assets = Rails.env.production?
+
+  # Timeout in seconds to wait when proxying to  a static server
+  #   (Applies when a site has both start_server and ping_server set to true)
+  # config.ping_server_timeout = 5
+
+  # The list of static sites you are hosting with static-rails.
+  # Note that order matters! Request will be forwarded to the first site that
+  # matches the subdomain and root path (this probably means you want any sites
+  # with subdomains listed first)
+  config.sites = [
+    # {
+    #   # Unique name for the site
+    #   name: "blog",
+    #
+    #   # File path to the static app relative to Rails root path
+    #   source_dir: "static/blog",
+    #
+    #   # Constrain static app to the following subdomain (omit or leave nil if you aren't hosting the site on a subdomain)
+    #   url_subdomain: "blog",
+    #
+    #   # Mount the static site web hosting to a certain sub-path (e.g. "/docs")
+    #   url_root_path: "/",
+    #
+    #   # Whether to run the local development/test server or not
+    #   start_server: !Rails.env.production?,
+    #
+    #   # If start_server is true, wait to proxy requests to the server until it can connect to server_host over TCP on server_port
+    #   ping_server: true
+    #
+    #   # The command to execute when running the static app in local development/test environments
+    #   server_command: "hugo server",
+    #
+    #   # The host the local development/test server should be reached on
+    #   server_host: "localhost",
+    #
+    #   # The port the local development/test server should be reached on
+    #   server_port: "1313",
+    #
+    #   # The root path on the local development/test server to which requests should be forwarded
+    #   server_path: "/",
+    #
+    #   # The command to execute when building the static app for production
+    #   compile_command: "hugo",
+    #
+    #   # The destination of the production-compiled assets, relative to Rails root
+    #   compile_dir: "static/blog/dist"
+    # },
+  ]
+end

data/lib/static-rails.rb

@@ -0,0 +1,8 @@
+module StaticRails
+end
+
+require_relative "static-rails/error"
+require_relative "static-rails/version"
+require_relative "static-rails/configuration"
+require_relative "static-rails/compile"
+require_relative "static-rails/railtie"

data/lib/static-rails/compile.rb

@@ -0,0 +1,21 @@
+module StaticRails
+  def self.compile
+    CompilesSites.new.call(StaticRails.config)
+  end
+
+  class CompilesSites
+    def call(config)
+      config.sites.each do |site|
+        Dir.chdir(config.app.root.join(site.source_dir)) do
+          Bundler.with_unbundled_env do
+            puts "=> Compiling static site \"#{site.name}\" to #{site.compile_dir}"
+            result = system site.compile_command
+            unless result == true
+              raise Error.new("Compilation of static site \"#{site.name}\" failed (in directory \"#{site.source_dir}\" with command: `#{site.compile_command}`)")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/static-rails/configuration.rb

@@ -0,0 +1,39 @@
+require_relative "site"
+
+module StaticRails
+  def self.config(&blk)
+    @configuration ||= Configuration.new
+
+    @configuration.tap do |config|
+      blk&.call(config)
+    end
+  end
+
+  class Configuration
+    # When Rails invokes our Railtie, we'll save off a reference to the Rails app
+    attr_accessor :app
+
+    # When true, the ProxyMiddleware will be added
+    attr_accessor :proxy_requests
+
+    # When true, the StaticMiddleware will be added
+    attr_accessor :serve_compiled_assets
+
+    # Number of seconds to wait on sites to confirm servers are ready
+    attr_accessor :ping_server_timeout
+
+    def initialize
+      @sites = []
+      @proxy_requests = !Rails.env.production?
+      @serve_compiled_assets = Rails.env.production?
+      @ping_server_timeout = 5
+    end
+
+    attr_reader :sites
+    def sites=(sites)
+      @sites = Array.wrap(sites).map { |site|
+        Site.new(site)
+      }
+    end
+  end
+end

data/lib/static-rails/error.rb

@@ -0,0 +1,3 @@
+module StaticRails
+  class Error < StandardError; end
+end

data/lib/static-rails/matches_request_to_static_site.rb

@@ -0,0 +1,24 @@
+module StaticRails
+  class MatchesRequestToStaticSite
+    def call(request)
+      StaticRails.config.sites.find { |site|
+        subdomain_match?(site, request) && path_match?(site, request)
+      }
+    end
+
+    private
+
+    def subdomain_match?(site, request)
+      return true if site.url_subdomain.nil?
+
+      expected = site.url_subdomain.split(".")
+      actual = request.host.split(".")
+
+      expected.enum_for.with_index.all? { |sub, i| actual[i] == sub }
+    end
+
+    def path_match?(site, request)
+      request.path_info.start_with?(site.url_root_path)
+    end
+  end
+end

data/lib/static-rails/proxy_middleware.rb

@@ -0,0 +1,51 @@
+require "rack-proxy"
+
+require_relative "matches_request_to_static_site"
+require_relative "server_store"
+
+module StaticRails
+  class ProxyMiddleware < Rack::Proxy
+    def initialize(app)
+      @matches_request_to_static_site = MatchesRequestToStaticSite.new
+      @app = app
+      @servers = {}
+      super
+    end
+
+    def perform_request(env)
+      return @app.call(env) unless StaticRails.config.proxy_requests
+      ServerStore.instance.ensure_all_servers_are_started
+
+      req = Rack::Request.new(env)
+      server_store = ServerStore.instance
+      server_store.ensure_servers_are_up
+
+      if (req.get? || req.head?) && (site = @matches_request_to_static_site.call(req))
+        if site.ping_server && (server = server_store.server_for(site))
+          server.wait_until_ready
+        end
+
+        @backend = URI("http://#{site.server_host}:#{site.server_port}")
+
+        env["HTTP_HOST"] = @backend.host
+        env["PATH_INFO"] = forwarding_path(site, req)
+        env["HTTP_COOKIE"] = ""
+        super(env)
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+
+    def forwarding_path(site, req)
+      req_path = req.path_info
+
+      if req_path == site.url_root_path && !req_path.end_with?("/")
+        req_path + "/" # <- Necessary for getting jekyll, possibly hugo to serve the root
+      else
+        req_path
+      end
+    end
+  end
+end

data/lib/static-rails/rack_server_check.rb

@@ -0,0 +1,36 @@
+module StaticRails
+  # Shamelessly ripped out of @danmeyer's Coverband: https://github.com/danmayer/coverband/blob/master/lib/coverband/integrations/rack_server_check.rb#L14
+  #
+  # Copyright (c) 2010-2018 Dan Mayer
+  #
+  # Distributed under the MIT License
+  #
+  # Details:
+  #   https://github.com/danmayer/coverband/blob/master/LICENSE.txt
+  class RackServerCheck
+    def self.running?
+      new(Kernel.caller_locations).running?
+    end
+
+    def initialize(stack)
+      @stack = stack
+    end
+
+    def running?
+      rack_server? || rails_server?
+    end
+
+    def rack_server?
+      @stack.any? { |line| line.path.include?("lib/rack/") }
+    end
+
+    def rails_server?
+      @stack.any? do |location|
+        (
+          (location.path.include?("rails/commands/commands_tasks.rb") && location.label == "server") ||
+          (location.path.include?("rails/commands/server/server_command.rb") && location.label == "perform")
+        )
+      end
+    end
+  end
+end

data/lib/static-rails/railtie.rb

@@ -0,0 +1,31 @@
+require_relative "rack_server_check"
+require_relative "server_store"
+require_relative "proxy_middleware"
+require_relative "static_middleware"
+
+module StaticRails
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load "tasks/static-rails.rake"
+    end
+
+    # Note that user initializer won't have run yet, but we seem to need to
+    # register the middleware by now if it's going to properly get added to the
+    # stack. So if the user overrides these flags' defaults, the middleware will
+    # still be added but will be responsible itself for skipping each request
+    if StaticRails.config.proxy_requests
+      config.app_middleware.insert_before 0, ProxyMiddleware
+    elsif StaticRails.config.serve_compiled_assets
+      config.app_middleware.insert_before 0, StaticMiddleware
+    end
+
+    config.after_initialize do |app|
+      static_rails_config = StaticRails.config
+      static_rails_config.app = app
+
+      if RackServerCheck.running?
+        ServerStore.instance.ensure_all_servers_are_started
+      end
+    end
+  end
+end

data/lib/static-rails/server.rb

@@ -0,0 +1,66 @@
+require_relative "waits_for_connection"
+
+module StaticRails
+  class Server
+    def initialize(site)
+      @site = site
+      @ready = false
+      @waits_for_connection = WaitsForConnection.new
+    end
+
+    def start
+      return if started?
+      @pid = spawn_process
+      set_at_exit_hook
+      nil
+    end
+
+    def started?
+      return false unless @pid.present?
+
+      begin
+        Process.getpgid(@pid)
+        true
+      rescue Errno::ESRCH
+        @ready = false
+        false
+      end
+    end
+
+    def wait_until_ready
+      return if @ready
+      @waits_for_connection.call(@site)
+      @ready = true
+    end
+
+    private
+
+    def spawn_process
+      options = {
+        in: "/dev/null",
+        out: "/dev/stdout",
+        err: "/dev/stderr",
+        close_others: true,
+        chdir: StaticRails.config.app.root.join(@site.source_dir).to_s
+      }
+
+      Rails.logger.info "=> Starting #{@site.name} static server"
+      Bundler.with_unbundled_env do
+        Process.spawn(ENV, @site.server_command, options).tap do |pid|
+          Process.detach(pid)
+        end
+      end
+    end
+
+    def set_at_exit_hook
+      return if @at_exit_hook_set
+      at_exit do
+        if started?
+          Rails.logger.info "=> Stopping #{@site.name} static server"
+          Process.kill("INT", @pid)
+        end
+      end
+      @at_exit_hook_set = true
+    end
+  end
+end

data/lib/static-rails/server_store.rb

@@ -0,0 +1,29 @@
+require_relative "server"
+
+module StaticRails
+  class ServerStore
+    def self.instance
+      @instance ||= new
+    end
+
+    def ensure_all_servers_are_started
+      StaticRails.config.sites.select(&:start_server).each do |site|
+        server_for(site).start
+      end
+    end
+
+    def server_for(site)
+      @servers[site] ||= Server.new(site)
+    end
+
+    def ensure_servers_are_up
+      @servers.values.each(&:start)
+    end
+
+    private
+
+    def initialize
+      @servers = {}
+    end
+  end
+end

data/lib/static-rails/site.rb

@@ -0,0 +1,33 @@
+module StaticRails
+  class Site < Struct.new(
+    :name,
+    :url_subdomain,
+    :url_root_path,
+    :source_dir,
+    :start_server,
+    :ping_server,
+    :server_command,
+    :server_host,
+    :server_port,
+    :server_path,
+    :compile_command,
+    :compile_dir,
+    keyword_init: true
+  )
+
+    def initialize(
+      url_root_path: "/",
+      start_server: !Rails.env.production?,
+      ping_server: true,
+      server_host: "localhost",
+      server_path: "/",
+      **other_kwargs
+    )
+      @start_server = start_server
+      @server_host = server_host
+      @server_path = server_path
+      @ping_server = ping_server
+      super
+    end
+  end
+end

data/lib/static-rails/static_middleware.rb

@@ -0,0 +1,39 @@
+require "rack-proxy"
+
+require_relative "matches_request_to_static_site"
+
+module StaticRails
+  class StaticMiddleware
+    def initialize(app)
+      @matches_request_to_static_site = MatchesRequestToStaticSite.new
+      @app = app
+      @file_handlers = {}
+    end
+
+    def call(env)
+      return @app.call(env) unless StaticRails.config.serve_compiled_assets
+      req = Rack::Request.new env
+
+      if (req.get? || req.head?) && (site = @matches_request_to_static_site.call(req))
+        file_handler = file_handler_for(site)
+        path = req.path_info.gsub(/^#{site.url_root_path}/, "").chomp("/")
+        if (match = file_handler.match?(path))
+          req.path_info = match
+          return file_handler.serve(req)
+        end
+      end
+
+      @app.call(req.env)
+    end
+
+    private
+
+    # The same file handler used by Rails when serving up files from /public
+    #   See: actionpack/lib/action_dispatch/middleware/static.rb
+    def file_handler_for(site)
+      @file_handlers[site] ||= ActionDispatch::FileHandler.new(
+        StaticRails.config.app.root.join(site.compile_dir).to_s
+      )
+    end
+  end
+end

data/lib/static-rails/version.rb

@@ -0,0 +1,3 @@
+module StaticRails
+  VERSION = "0.0.1"
+end

data/lib/static-rails/waits_for_connection.rb

@@ -0,0 +1,25 @@
+module StaticRails
+  class WaitsForConnection
+    def call(site)
+      timeout = StaticRails.config.ping_server_timeout
+      start = Time.new
+      wait_message_logged = false
+
+      loop do
+        Socket.tcp(site.server_host, site.server_port, connect_timeout: 5)
+        break
+      rescue Errno::ECONNREFUSED
+        elapsed = Time.new - start
+        if elapsed > timeout
+          raise Error.new("Static site server \"#{site.name}\" failed to start within #{timeout} seconds. You can change the timeout with `StaticRails.config.ping_server_timeout = 42`")
+        else
+          unless wait_message_logged
+            Rails.logger.info "=> Static site server \"#{site.name}\" is not yet accepting connections on #{site.server_host}:#{site.server_port}. Will try to connect for #{timeout} more seconds"
+            wait_message_logged = true
+          end
+          sleep 0.3
+        end
+      end
+    end
+  end
+end

data/lib/tasks/static-rails.rake

@@ -0,0 +1,20 @@
+$stdout.sync = true
+
+def enhance_assets_precompile
+  Rake::Task["assets:precompile"].enhance([]) do
+    Rake::Task["static:compile"].invoke
+  end
+end
+
+namespace :static do
+  desc "Compile static sites configured with static-rails"
+  task compile: :environment do
+    StaticRails.compile
+  end
+end
+
+if Rake::Task.task_defined?("assets:precompile")
+  enhance_assets_precompile
+else
+  Rake::Task.define_task("assets:precompile" => "static:compile")
+end

data/static-rails.gemspec

@@ -0,0 +1,25 @@
+require_relative "lib/static-rails/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "static-rails"
+  spec.version = StaticRails::VERSION
+  spec.authors = ["Justin Searls"]
+  spec.email = ["searls@gmail.com"]
+
+  spec.summary = "Build & serve static sites (e.g. Jekyll, Hugo) from your Rails app"
+  spec.homepage = "https://github.com/testdouble/static-rails"
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|example)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "railties", ">= 5.0.0"
+  spec.add_dependency "rack-proxy", "~> 0.6"
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: static-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Justin Searls
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: rack-proxy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: 
+email:
+- searls@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".gitignore"
+- ".standard.yml"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/generators/static_rails/initializer_generator.rb
+- lib/generators/templates/static.rb
+- lib/static-rails.rb
+- lib/static-rails/compile.rb
+- lib/static-rails/configuration.rb
+- lib/static-rails/error.rb
+- lib/static-rails/matches_request_to_static_site.rb
+- lib/static-rails/proxy_middleware.rb
+- lib/static-rails/rack_server_check.rb
+- lib/static-rails/railtie.rb
+- lib/static-rails/server.rb
+- lib/static-rails/server_store.rb
+- lib/static-rails/site.rb
+- lib/static-rails/static_middleware.rb
+- lib/static-rails/version.rb
+- lib/static-rails/waits_for_connection.rb
+- lib/tasks/static-rails.rake
+- static-rails.gemspec
+homepage: https://github.com/testdouble/static-rails
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/testdouble/static-rails
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Build & serve static sites (e.g. Jekyll, Hugo) from your Rails app
+test_files: []