confinement 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e85abea697c0437610597a3c221c833d97931bace819ba66ebb7c02d48ed6c20
+  data.tar.gz: b611ce215a7c6057fe2e874707e314b0644f7f0732229810127cd7c7702fb572
+SHA512:
+  metadata.gz: bdc4a25ecacc5d1c378f589d28cef55e63cfd3bbd6353ba9b1cf2439ae08f7bc219f2f77f2257d4bcf887fb7e85c8a6d659097f4a7052c5e47b72d7727b9cbde
+  data.tar.gz: 17527d0a0f6307a5c2dc2b7b2ae445294c03afe5ffea69f20f3dabd3a6ac0a432181d82a8be7985666e01c875ff03f128aacc7add2a6968bda4770b17512c8a4

data/.gitignore

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

data/.ruby-version

@@ -0,0 +1 @@
+2.7.0

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.5
+before_install: gem install bundler -v 1.17.3

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in confinement.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    confinement (0.0.1)
+      erubi
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (11.1.1)
+    coderay (1.1.2)
+    erubi (1.9.0)
+    method_source (1.0.0)
+    minitest (5.14.0)
+    pry (0.13.0)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.9.0)
+      byebug (~> 11.0)
+      pry (~> 0.13.0)
+    rake (13.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  confinement!
+  minitest (~> 5.0)
+  pry-byebug
+  rake (~> 13.0)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Zach Ahn
+
+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,59 @@
+# Confinement
+
+A static site generator for when you're stuck at home.
+
+Assets are generated through the (nightly) [Parcel bundler][parcel2].
+
+
+## Installation
+
+Confinement requires Ruby 2.7+, Node 10+, and Yarn.
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "confinement"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install confinement
+
+
+## Usage
+
+```sh
+confinement init path/to/new/site
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake test` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/zachahn/confinement.
+
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).
+
+
+[parcel2]: https://github.com/parcel-bundler/parcel/tree/v2

data/Rakefile

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

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "confinement"
+
+# 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/rake

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

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/confinement.gemspec

@@ -0,0 +1,32 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "confinement/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "confinement"
+  spec.version = Confinement::VERSION
+  spec.authors = ["Zach Ahn"]
+  spec.email = ["engineering@zachahn.com"]
+
+  spec.summary = "Static site generator for when you're stuck at home"
+  spec.homepage = "https://github.com/zachahn/confinement"
+  spec.license = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "pry-byebug"
+
+  spec.add_runtime_dependency("erubi")
+end

data/exe/confinement

@@ -0,0 +1,237 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+if File.exist?(File.expand_path("../.git", __dir__))
+  lib = File.expand_path("../lib", __dir__)
+  $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+end
+
+require "optparse"
+require "pathname"
+
+require "confinement/version"
+
+module Confinement
+  class CLI
+    def self.subcommands
+      @subcommands ||= {
+        "init" => Init.new,
+      }
+    end
+
+    def self.script_name
+      @script_name ||= File.basename(__FILE__)
+    end
+
+    def optparser
+      @optparser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: #{CLI.script_name} [options] [subcommand [options]]"
+
+        opts.on("--version", "Print version (#{Confinement::VERSION})") do
+          puts Confinement::VERSION
+          exit
+        end
+
+        opts.on("-h", "--help", "Prints this help message") do
+        end
+      end
+    end
+
+    def call(argv)
+      optparser.order!(argv)
+      subcommand_name = argv.shift
+
+      if subcommand_name.nil?
+        puts(optparser)
+        exit
+      end
+
+      if !self.class.subcommands.key?(subcommand_name)
+        $stderr.puts("#{CLI.script_name}: `#{subcommand_name}` is not valid command")
+        $stderr.puts
+        $stderr.puts(optparser)
+        exit(1)
+      end
+
+      subcommand = self.class.subcommands.fetch(subcommand_name)
+      subcommand.optparser.parse!(argv)
+      subcommand.call(argv)
+    end
+
+    private
+
+    class Init
+      def optparser
+        @options ||= {}
+        @optparser ||= OptionParser.new do |opts|
+          opts.banner = "Usage: #{CLI.script_name} init [directory]"
+
+          opts.on("--force", "Write files without prompting") do
+            @force = true
+          end
+
+          opts.on("--skip", "Skip files without prompting") do
+            @skip = true
+          end
+
+          opts.on("-h", "--help", "Prints this help message") do
+            puts opts
+            exit
+          end
+        end
+      end
+
+      def call(argv)
+        if argv.size != 1
+          puts optparser
+          exit
+        end
+
+        require "open3"
+
+        root = Pathname.new(argv.first).expand_path
+
+        templates = DATA.read.split(/^==> /)[1..-1]
+        templates = templates.filter_map do |template|
+          path, *body = template.lines
+          body = body.join("")
+
+          [Pathname.new(File.join(root, path.strip)), body.strip + "\n"]
+        end
+
+        templates
+          .map { |path, _| path.dirname }
+          .uniq
+          .each { |path| mkdir(path, root) }
+
+        templates.each do |path, body|
+          write(path, body, root)
+        end
+
+        Dir.chdir(root) do
+          run(["yarn", "init", "--yes"])
+
+          run(["yarn", "add", "--dev", "parcel@nightly"])
+        end
+      end
+
+      private
+
+      def run(command)
+        status("exec", command.join(" "))
+        Open3.capture2(*command)
+      end
+
+      def write(path, body, root)
+        relpath = path.relative_path_from(root.dirname)
+
+        if path.exist?
+          if @skip
+            status("skip", relpath)
+          elsif @force
+            status("force", relpath)
+            path.write(body)
+          elsif yes?("overwrite #{path}?")
+            status("overwrite", relpath)
+            path.write(body)
+          else
+            status("skip", relpath)
+          end
+        else
+          status("write", relpath)
+          path.write(body)
+        end
+      end
+
+      def mkdir(dir, root)
+        if dir.exist?
+          status("exist", dir.relative_path_from(root.dirname))
+        else
+          status("mkdir", dir.relative_path_from(root.dirname))
+          dir.mkdir
+        end
+      end
+
+      def status(action, object)
+        space = 12 - action.size
+        puts "    #{action}#{" " * space}#{object}"
+      end
+
+      def yes?(question)
+        print "#{question} (y/N) "
+        answer = $stdin.gets
+
+        return false if answer.nil?
+
+        /^y/i.match?(answer)
+      end
+    end
+  end
+end
+
+Confinement::CLI.new.call(ARGV.dup)
+
+__END__
+==> boot.rb
+require "confinement"
+
+Confinement.root = __dir__
+
+Confinement.site = Confinement::Builder.new(
+  root: Confinement.root,
+  assets: "assets",
+  contents: "contents",
+  layouts: "layouts",
+  config: {
+    index: "index.html",
+  }
+)
+
+==> build.rb
+require_relative "boot"
+
+using Confinement::Easier
+
+Confinement.site.contents do |contents, layouts, dest|
+  dest["/"] = Confinement::Content.new(
+    layout: layouts.join("default.html.erb"),
+    input_path: contents.join("index.html.erb"),
+    renderers: [Confinement::Renderer::Erb.new]
+  )
+end
+
+Confinement.site.assets do |assets, dest|
+  dest["/assets/application.js"] = Confinement::Asset.new(
+    input_path: assets.join("application.js"),
+    entrypoint: true,
+  )
+
+  dest["/assets/application.css"] = Confinement::Asset.new(
+    input_path: assets.join("application.css"),
+    entrypoint: false,
+  )
+end
+
+Confinement.site.layouts do |layouts, dest|
+  dest[layouts.join("default.html.erb")] = Confinement::Layout.new(
+    renderers: [Confinement::Renderer::Erb.new]
+  )
+end
+
+==> write.rb
+require_relative "build"
+
+Confinement::Publish
+  .new(Confinement.site)
+  .write(Confinement.root.join("public"))
+
+==> assets/application.js
+import "./application.css";
+
+==> assets/application.css
+
+==> layouts/default.html.erb
+
+==> contents/index.html.erb
+
+

data/lib/confinement.rb

@@ -0,0 +1,570 @@
+# frozen_string_literal: true
+
+if Gem.loaded_specs.has_key?("pry-byebug")
+  require "pry-byebug"
+elsif Gem.loaded_specs.has_key?("pry-byebug")
+  require "pry"
+end
+
+# standard library
+require "digest"
+require "open3"
+require "pathname"
+require "yaml"
+
+# gems
+require "erubi"
+
+# internal
+require_relative "confinement/version"
+
+module Confinement
+  class Error < StandardError
+    class PathDoesNotExist < Error; end
+  end
+
+  FRONTMATTER_REGEX =
+    /\A
+      (?<possible_frontmatter_section>
+        (?<frontmatter>^---\n
+        .*?)
+        ^---\n)?
+      (?<body>.*)
+    \z/mx
+
+  PATH_INCLUDE_PATH_REGEX = /\A\.\.(\z|\/)/
+
+  module Easier
+    # NOTE: Avoid state - Pathname is supposed to be immutable
+    refine Pathname do
+      # Pathname#join and File.join behave very differently
+      #
+      # - Pathname.new("foo").join("/bar") # => Pathname.new("/bar")
+      # - File.join("foo", "/bar") # => "foo/bar"
+      def concat(*parts)
+        Pathname.new(File.join(self, *parts))
+      end
+
+      def include?(other)
+        difference = other.relative_path_from(self)
+
+        !PATH_INCLUDE_PATH_REGEX.match?(difference.to_s)
+      end
+    end
+
+    refine String do
+      def frontmatter_and_body(strip: true)
+        matches = FRONTMATTER_REGEX.match(self)
+
+        return [{}, self] if matches["frontmatter"].nil?
+
+        frontmatter = YAML.safe_load(matches["frontmatter"])
+        body = matches["body"] || ""
+        body = body.strip if strip
+
+        [frontmatter, body]
+      rescue ArgumentError
+        [{}, self]
+      end
+    end
+  end
+
+  using Easier
+
+  class << self
+    attr_reader :root
+    attr_accessor :site
+
+    def root=(path)
+      # NOTE: Pathname.new(Pathname.new(".")) == Pathname.new(".")
+      path = Pathname.new(path).expand_path
+      path = path.expand_path
+
+      if !path.exist?
+        raise Error::PathDoesNotExist, "Root path does not exist: #{path}"
+      end
+
+      @root = path
+    end
+  end
+
+  class Builder
+    def initialize(root:, assets:, contents:, layouts:, config: {})
+      @root = root
+      @assets = assets
+      @contents = contents
+      @layouts = layouts
+      @config = {
+        index: config.fetch(:index, "index.html")
+      }
+
+      @output_root = root.concat(config.fetch(:destination_root, "public"))
+      @assets_root = @output_root.concat(config.fetch(:assets_subdirectory, "assets"))
+
+      @representation = Representation.new
+    end
+
+    attr_reader :root
+    attr_reader :output_root
+    attr_reader :assets_root
+    attr_reader :representation
+    attr_reader :config
+
+    def contents_path
+      @contents_path ||= @root.concat(@contents)
+    end
+
+    def layouts_path
+      @layouts_path ||= @root.concat(@layouts)
+    end
+
+    def assets_path
+      @assets_path ||= @root.concat(@assets)
+    end
+
+    def layouts
+      if !layouts_path.exist?
+        raise PathDoesNotExist, "Layouts path doesn't exist: #{layouts_path}"
+      end
+
+      yield(layouts_path, @representation.layouts)
+    end
+
+    def assets
+      if !assets_path.exist?
+        raise PathDoesNotExist, "Assets path doesn't exist: #{assets_path}"
+      end
+
+      yield(assets_path, @representation.assets)
+    end
+
+    def contents
+      if !contents_path.exist?
+        raise PathDoesNotExist, "Contents path doesn't exist: #{contents_path}"
+      end
+
+      yield(contents_path, layouts_path, @representation.contents)
+    end
+  end
+
+  class Representation
+    include Enumerable
+
+    def initialize
+      @lookup = {}
+      @layouts_lookup = {}
+      @only_assets = []
+      @only_contents = []
+    end
+
+    attr_reader :only_assets
+    attr_reader :layouts_lookup
+    attr_reader :only_contents
+
+    def fetch(key)
+      if !@lookup.key?(key)
+        raise "Not represented!"
+      end
+
+      @lookup[key]
+    end
+
+    def each
+      if !block_given?
+        return enum_for(:each)
+      end
+
+      @lookup.each do |identifier, page|
+        yield(identifier, page)
+      end
+    end
+
+    def layouts
+      Setter.new(@layouts_lookup) do |path, layout|
+        layout.input_path = path
+      end
+    end
+
+    def assets
+      Setter.new(@lookup) do |identifier, asset|
+        @only_assets.push(asset)
+        asset.url_path = identifier
+      end
+    end
+
+    def contents
+      Setter.new(@lookup) do |identifier, content|
+        @only_contents.push(content)
+        content.url_path = identifier
+      end
+    end
+
+    def routes_getter
+      LookupGetter.new(@lookup)
+    end
+
+    def layouts_getter
+      LookupGetter.new(@layouts_lookup)
+    end
+
+    class Setter
+      def initialize(lookup, &block)
+        @lookup = lookup
+        @block = block
+      end
+
+      def []=(key, value)
+        @block&.call(key, value)
+
+        @lookup[key] = value
+      end
+    end
+
+    class LookupGetter
+      def initialize(lookup)
+        @lookup = lookup
+      end
+
+      def [](key)
+        @lookup.fetch(key)
+      end
+    end
+  end
+
+  module Blob
+    attr_accessor :input_path
+    attr_accessor :output_path
+    attr_reader :url_path
+
+    def url_path=(path)
+      if path.nil?
+        @url_path = nil
+        return
+      end
+
+      path = path.to_s
+      if path[0] != "/"
+        path = "/#{path}"
+      end
+
+      @url_path = path
+    end
+  end
+
+  class Asset
+    include Blob
+
+    def initialize(input_path:, entrypoint:)
+      self.input_path = input_path
+
+      @entrypoint = entrypoint
+      @url_path = nil
+    end
+
+    attr_accessor :rendered_body
+
+    def entrypoint?
+      !!@entrypoint
+    end
+  end
+
+  class Content
+    include Blob
+
+    def initialize(layout: nil, input_path: nil, locals: {}, renderers: [])
+      self.input_path = input_path
+
+      @layout = layout
+      @locals = locals
+      @renderers = renderers
+    end
+
+    attr_reader :locals
+    attr_reader :renderers
+    attr_reader :layout
+
+    attr_accessor :rendered_body
+  end
+
+  class Layout
+    def initialize(renderers:)
+      @renderers = renderers
+    end
+
+    attr_reader :renderers
+    attr_accessor :input_path
+  end
+
+  class Renderer
+    class Erb
+      def call(source, view_context, &block)
+        method_name = "_#{Digest::MD5.hexdigest(source)}"
+
+        compile(method_name, source, view_context)
+
+        view_context.public_send(method_name, &block)
+      end
+
+      private
+
+      def compile(method_name, source, view_context)
+        if !view_context.respond_to?(method_name)
+          compiled_erb = Erubi::Engine.new(source).src
+
+          view_context.instance_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def #{method_name}
+              #{compiled_erb}
+            end
+          RUBY
+        end
+      end
+    end
+  end
+
+  class Rendering
+    class ViewContext
+      def initialize(routes:, layouts:, locals:, frontmatter:, contents_path:, layouts_path:)
+        @routes = routes
+        @layouts = layouts
+
+        @locals = locals
+        @frontmatter = frontmatter
+
+        @contents_path = contents_path
+        @layouts_path = layouts_path
+      end
+
+      attr_reader :routes
+      attr_reader :layouts
+      attr_reader :locals
+      attr_reader :frontmatter
+      attr_reader :contents_path
+      attr_reader :layouts_path
+
+      def render(path = nil, inline: nil, layout: nil, renderers:, &block)
+        body =
+          if inline
+            inline
+          elsif path
+            path.read
+          else
+            raise %(Must pass in either a Pathname or `inline: 'text'`)
+          end
+
+        render_chain = RenderChain.new(
+          body: body,
+          layout: layout,
+          renderers: renderers,
+          view_context: self
+        )
+        rendered_body = render_chain.call(&block)
+
+        if layout
+          layout =
+            if layout.is_a?(Layout)
+              layout
+            elsif layout.is_a?(Pathname)
+              layouts[layout]
+            else
+              raise "Expected layout to be a Layout or Pathname"
+            end
+
+          layout_render_chain = RenderChain.new(
+            body: layout.input_path.read,
+            layout: nil,
+            renderers: layout.renderers,
+            view_context: self
+          )
+
+          layout_render_chain.call do
+            rendered_body
+          end
+        else
+          rendered_body
+        end
+      end
+    end
+
+    class RenderChain
+      def initialize(body:, layout:, renderers:, view_context:)
+        @body = body
+        @layout = layout
+        @renderers = renderers
+        @view_context = view_context
+      end
+
+      def call(&block)
+        @renderers.reduce(@body) do |memo, renderer|
+          renderer.call(memo, @view_context, &block)
+        end
+      end
+    end
+  end
+
+  class HesitantCompiler
+    def initialize(site)
+      @site = site
+      @lock = Mutex.new
+    end
+
+    attr_reader :site
+
+    def compile_everything
+      # All compilation happens inside the same lock. So we shouldn't have
+      # to worry about deadlocks or anything
+      @lock.synchronize do
+        # Assets first since it's almost always a dependency of contents
+        compile_assets(site.representation.only_assets)
+        compile_contents(site.representation.only_contents)
+      end
+    end
+
+    private
+
+    PARCEL_FILES_OUTPUT_REGEX = /^✨[^\n]+\n\n(.*)Done in(?:.*)\z/m
+    PARCEL_FILE_OUTPUT_REGEX = /^(?<page>.*?)\s+(?<size>[0-9\.]+\s*[A-Z]?B)\s+(?<time>[0-9\.]+[a-z]?s)$/
+
+    def compile_assets(assets)
+      if assets_dirty?
+        out, status = Open3.capture2(
+          "yarn",
+          "run",
+          "parcel",
+          "build",
+          "--dist-dir", site.assets_root.to_s,
+          "--public-url", site.assets_root.basename.to_s,
+          *assets.select(&:entrypoint?).map(&:input_path).map(&:to_s)
+        )
+
+        if !status.success?
+          raise "Asset compilation failed"
+        end
+
+        matches = PARCEL_FILES_OUTPUT_REGEX.match(out)[1]
+
+        if !matches
+          raise "Asset parsing failed"
+        end
+
+        processed_file_paths = matches.split("\n\n")
+
+        representation_by_input_path =
+          site.representation.only_assets.filter_map do |page|
+            next if page.input_path.nil?
+
+            [page.input_path, page]
+          end
+          .to_h
+
+        processed_file_paths.map do |file|
+          output_file, input_file = file.strip.split("\n└── ")
+
+          output_path = site.root.concat(output_file[PARCEL_FILE_OUTPUT_REGEX, 1])
+          input_path = site.root.concat(input_file[PARCEL_FILE_OUTPUT_REGEX, 1])
+
+          if !representation_by_input_path.key?(input_path)
+            next
+          end
+
+          url_path = output_path.relative_path_from(site.output_root)
+          representation_by_input_path[input_path].url_path = url_path.to_s
+          representation_by_input_path[input_path].output_path = output_path
+          representation_by_input_path[input_path].rendered_body = output_path.read
+        end
+      end
+    end
+
+    def compile_content(content)
+      if content.rendered_body
+        return
+      end
+
+      content_body = content.input_path.read
+      frontmatter, content_body = content_body.frontmatter_and_body
+
+      view_context = Rendering::ViewContext.new(
+        routes: site.representation.routes_getter,
+        layouts: site.representation.layouts_getter,
+        locals: content.locals,
+        frontmatter: frontmatter,
+        contents_path: site.contents_path,
+        layouts_path: site.layouts_path
+      )
+
+      content.rendered_body = view_context.render(
+        inline: content_body,
+        layout: content.layout,
+        renderers: content.renderers
+      )
+      content.rendered_body ||= ""
+
+      content.output_path =
+        if content.url_path[-1] == "/"
+          site.output_root.concat(content.url_path, site.config.fetch(:index))
+        else
+          site.output_root.concat(content.url_path)
+        end
+
+      if content.output_path.exist?
+        if content.output_path.read == content.rendered_body
+          return
+        end
+      end
+
+      if !site.output_root.include?(content.output_path)
+        return
+      end
+
+      if !content.output_path.dirname.directory?
+        content.output_path.dirname.mkpath
+      end
+
+      content.output_path.write(content.rendered_body)
+
+      nil
+    end
+
+    def compile_contents(contents)
+      return if !contents_dirty?
+
+      contents.each do |content|
+        compile_content(content)
+      end
+    end
+
+    private
+
+    def contents_dirty?
+      true
+    end
+
+    def assets_dirty?
+      true
+    end
+  end
+
+  class Publish
+    def initialize(site)
+      @site = site
+      @compiler = HesitantCompiler.new(@site)
+    end
+
+    def write(path)
+      find_or_raise_or_mkdir(path)
+
+      @compiler.compile_everything
+    end
+
+    private
+
+    def find_or_raise_or_mkdir(destination)
+      if !destination.exist?
+        if !destination.dirname.exist?
+          raise Error::PathDoesNotExist, "Destination's parent path does not exist: #{destination.dirname}"
+        end
+
+        destination.mkpath
+      end
+    end
+  end
+end

data/lib/confinement/version.rb

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

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: confinement
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Zach Ahn
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  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: erubi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- engineering@zachahn.com
+executables:
+- confinement
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/rake
+- bin/setup
+- confinement.gemspec
+- exe/confinement
+- lib/confinement.rb
+- lib/confinement/version.rb
+homepage: https://github.com/zachahn/confinement
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.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: Static site generator for when you're stuck at home
+test_files: []