confinement 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a991bdb8646d092772f6ae7154bc34c7c89ac4faf8d51822e7b1361ed8f7ec05
-  data.tar.gz: 073003314b979b4bbf03dc3baf487030e6a07199feef361b5addad3928a7b06c
+  metadata.gz: 317875d42d9d6449fe4f5ba24a5411defb9211b88a22270cac6457afa55308bb
+  data.tar.gz: 331794f2b0b08897f03c40b5147d08cc474d76ee941f8e87d264042256f84d77
 SHA512:
-  metadata.gz: 72cffafd98539f4655a039c674d9324e998ef508610bad89f9f6e21a5d06cd158487413b60bdeb6b961d76f338c44013bb4ff9f35ea0733ffba74856f01046d8
-  data.tar.gz: 1d6076cc1b834d0a3bf3cd9fcaee3dc7cabd6e048e3f5dc298a7d201c6b60d44f63f0a5f164378c0a9883d9a19e6c83e422a0b9b07d2727164e6e7f2a2493343
+  metadata.gz: 53a6285bc8cacda51cb4a4edd45562ce41ba7b483f643032276b5720dae0b774137324c3ca410dde65b9a007369a334d8b71cd0f427788edc67a0db244f4cc91
+  data.tar.gz: b6713bcc1eff930f4e4007d85579090409e2f56196abc533170b85ea5858be96876a6e8c029cb0ad4045fdbe501962c9439582231cbf46363803587db96687eb

data/Gemfile.lock

@@ -1,24 +1,28 @@
 PATH
   remote: .
   specs:
-    confinement (0.0.2)
+    confinement (0.0.3)
       erubi
+      puma (~> 4.3)
+      rack (~> 2.2)
+      zeitwerk (~> 2.3)
 
 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)
+    nio4r (2.5.2)
     pry (0.13.0)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    pry-byebug (3.9.0)
-      byebug (~> 11.0)
-      pry (~> 0.13.0)
+    puma (4.3.3)
+      nio4r (~> 2.0)
+    rack (2.2.2)
     rake (13.0.1)
+    zeitwerk (2.3.0)
 
 PLATFORMS
   ruby
@@ -27,7 +31,7 @@ DEPENDENCIES
   bundler (~> 2.0)
   confinement!
   minitest (~> 5.0)
-  pry-byebug
+  pry
   rake (~> 13.0)
 
 BUNDLED WITH

data/README.md

@@ -28,6 +28,8 @@ Or install it yourself as:
 
 ```sh
 confinement init path/to/new/site
+cd path/to/new/site
+confinement server # or confinement build
 ```
 
 

data/confinement.gemspec

@@ -26,7 +26,10 @@ Gem::Specification.new do |spec|
   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_development_dependency "pry"
 
   spec.add_runtime_dependency("erubi")
+  spec.add_runtime_dependency("zeitwerk", "~> 2.3")
+  spec.add_runtime_dependency("rack", "~> 2.2")
+  spec.add_runtime_dependency("puma", "~> 4.3")
 end

data/exe/confinement

@@ -9,6 +9,7 @@ end
 require "optparse"
 require "pathname"
 
+require "confinement"
 require "confinement/version"
 
 module Confinement
@@ -16,6 +17,8 @@ module Confinement
     def self.subcommands
       @subcommands ||= {
         "init" => Init.new,
+        "server" => Server.new,
+        "build" => Build.new,
       }
     end
 
@@ -34,6 +37,12 @@ module Confinement
 
         opts.on("-h", "--help", "Prints this help message") do
         end
+
+        opts.separator("")
+        opts.separator("Subcommands")
+        self.class.subcommands.each do |name, _|
+          opts.separator("    #{name}")
+        end
       end
     end
 
@@ -60,6 +69,202 @@ module Confinement
 
     private
 
+    class Build
+      def optparser
+        @options ||= {
+          "--setup" => "config/setup.rb",
+          "--rules" => "rules.rb",
+        }
+        @optparser ||= OptionParser.new do |opts|
+          opts.banner = "Usage: #{CLI.script_name} build [options]"
+          opts.on("--setup=PATH", "Path to setup file (default: #{@options["--setup"]})") do |path|
+            @options["--setup"] = path
+          end
+          opts.on("--rules=PATH", "Path to rules file (default: #{@options["--rules"]})") do |path|
+            @options["--rules"] = path
+          end
+          opts.on("--help", "Print this help message") do
+            puts self
+            exit
+          end
+        end
+      end
+
+      def call(argv)
+        setup_path = @options.fetch("--setup")
+        rules_path = @options.fetch("--rules")
+
+        load Pathname.new(setup_path).expand_path
+        @compiler = Compiler.new(Confinement.config)
+
+        load Pathname.new(rules_path).expand_path
+        @compiler.compile_everything(Confinement.site)
+      end
+    end
+
+    class Server
+      using Easier
+
+      def optparser
+        @options ||= {
+          "--setup" => "config/setup.rb",
+          "--rules" => "rules.rb",
+          "--port" => "7000"
+        }
+        @optparser ||= OptionParser.new do |opts|
+          opts.banner = "Usage: #{CLI.script_name} server [options]"
+          opts.on("--setup=PATH", "Path to setup file (default: #{@options["--setup"]})") do |path|
+            @options["--setup"] = path
+          end
+          opts.on("--rules=PATH", "Path to rules file (default: #{@options["--rules"]})") do |path|
+            @options["--rules"] = path
+          end
+          opts.on("--port=PORT", "Port to listen to (default: #{@options["--port"]})") do |port|
+            @options["--port"] = port
+          end
+        end
+      end
+
+      def call(argv)
+        if argv.size > 1
+          puts optparser
+          exit
+        end
+
+        setup_path = @options.fetch("--setup")
+        rules_path = @options.fetch("--rules")
+
+        setup_path = Pathname.new(setup_path).expand_path
+        rules_path = Pathname.new(rules_path).expand_path
+
+        if !setup_path.exist?
+          raise "Cannot find setup file at: #{setup_path}"
+        end
+
+        require "rack"
+        require "puma"
+        require "puma/configuration"
+        require "confinement/filewatcher/filewatcher"
+
+        load setup_path
+
+        dirty = Dirty.new
+
+        puma_config = Puma::Configuration.new do |user_config, file_config, default_config|
+          user_config.port(@options.fetch("--port").to_i)
+          user_config.app(Rack::CommonLogger.new(App.new(Confinement.config, rules_path, dirty)))
+        end
+
+        assets_filewatcher = Filewatcher.new(Confinement.config.watcher.assets)
+        contents_filewatcher = Filewatcher.new(Confinement.config.watcher.contents)
+        puma_launcher = Puma::Launcher.new(puma_config, events: Puma::Events.stdio)
+
+        assets_thread = Thread.new do
+          assets_filewatcher.watch { dirty.dirty_assets! }
+        end
+
+        contents_thread = Thread.new do
+          contents_filewatcher.watch { dirty.dirty_contents! }
+        end
+
+        puma_launcher.run
+      end
+
+      class Dirty
+        def initialize
+          @dirty_assets = true
+          @dirty_contents = true
+          @mutex = Mutex.new
+        end
+
+        def dirty_assets!
+          @mutex.synchronize { @dirty_assets = true }
+        end
+
+        def dirty_contents!
+          @mutex.synchronize { @dirty_contents = true }
+        end
+
+        def clean!
+          @mutex.synchronize do
+            if @dirty_assets || @dirty_contents
+              yield(@dirty_assets, @dirty_contents)
+            end
+
+            @dirty_assets = false
+            @dirty_contents = false
+          end
+        end
+      end
+
+      class App
+        def initialize(config, rules_path, dirty)
+          @config = config
+          @logger = config.logger
+          @rules_path = rules_path
+          @dirty = dirty
+          @output_root_path = config.compiler.output_root_path
+          @output_directory_index = config.compiler.output_directory_index
+          @compiler = Compiler.new(config)
+          @reload = false
+        end
+
+        def call(env)
+          if !["GET", "HEAD"].include?(env["REQUEST_METHOD"])
+            return [405, { "Content-Type" => "text/plain" }, ["Unsupported method: ", env["REQUEST_METHOD"]]]
+          end
+
+          @dirty.clean! do |is_dirty_assets, is_dirty_contents|
+            @logger.debug { "dirty: assets=#{is_dirty_assets}, contents=#{is_dirty_contents}" }
+
+            if @reload
+              @logger.debug { "reloading with Zeitwerk" }
+              Confinement.config.loader.reload
+            else
+              @reload = true
+            end
+
+            if is_dirty_assets
+              @logger.debug { "loading: #{@rules_path}" }
+              load @rules_path
+              @compiler.compile_everything(Confinement.site)
+            elsif is_dirty_contents
+              partial_compilation = Confinement.site.partial_compilation
+              @logger.debug { "loading: #{@rules_path}" }
+              load @rules_path
+              precompilation_partial_compilation = Confinement.site.partial_compilation
+
+              if @compiler.partial_compilation_dirty?(before: partial_compilation, after: precompilation_partial_compilation)
+                @logger.info { "detected asset change" }
+                @compiler.compile_everything(Confinement.site)
+              else
+                Confinement.site.partial_compilation = partial_compilation
+                @compiler.compile_contents(Confinement.site)
+              end
+            end
+
+            @logger.debug { "dirty: finished!" }
+          end
+
+          file_path = @output_root_path.concat(env["SCRIPT_NAME"] + env["PATH_INFO"])
+
+          if file_path.directory?
+            file_path = file_path.concat(@output_directory_index)
+          end
+
+          if !file_path.exist?
+            return [404, {}, ["Page not found!\n", file_path.to_s]]
+          end
+
+          if env["REQUEST_METHOD"] == "HEAD"
+            return [204, {}, []]
+          end
+
+          [200, {}, [file_path.read]]
+        end
+      end
+    end
+
     class Init
       def optparser
         @options ||= {}
@@ -99,10 +304,14 @@ module Confinement
           [Pathname.new(File.join(root, path.strip)), body.strip + "\n"]
         end
 
+        mkdir(root, root)
+        mkdir(root.join("lib"), root)
+        mkdir(root.join("tmp"), root)
+
         templates
           .map { |path, _| path.dirname }
           .uniq
-          .each { |path| mkdir(path, root) }
+          .each { |path| mkdir(path, root) if path != root }
 
         templates.each do |path, body|
           write(path, body, root)
@@ -175,25 +384,47 @@ end
 Confinement::CLI.new.call(ARGV.dup)
 
 __END__
-==> boot.rb
+==> config/boot.rb
 require "confinement"
 
-Confinement.root = __dir__
+==> config/setup.rb
+require_relative "boot"
 
-Confinement.site = Confinement::Site.new(
-  root: Confinement.root,
-  assets: "assets",
-  contents: "contents",
-  layouts: "layouts",
-  config: {
-    index: "index.html",
-  }
-)
+Confinement.config = Confinement::Config.new(root: File.dirname(__dir__))
 
-==> build.rb
-require_relative "boot"
+Confinement.config.compiler do |compiler|
+  compiler.output_root = compiler.default_output_root
+  compiler.output_assets = "assets"
+  compiler.output_directory_index = "index.html"
+end
+
+Confinement.config.source do |source|
+  source.assets = "assets"
+  source.contents = "contents"
+  source.layouts = "layouts"
+end
 
-Confinement.site.build do |assets:, layouts:, contents:, routes:|
+Confinement.config.loader do |loader|
+  loader.push_dir("lib")
+  loader.enable_reloading
+end
+
+Confinement.config.watcher do |paths|
+  paths.assets.push("assets/")
+  paths.assets.push("package.json")
+  paths.assets.push("yarn.lock")
+  paths.contents.push("contents/")
+  paths.contents.push("lib/")
+  paths.contents.push("rules.rb")
+end
+
+==> rules.rb
+Confinement.site = Confinement::Site.new(Confinement.config) do |site|
+  site.view_context_helpers = []
+  site.guesses = Confinement::Renderer.guesses
+end
+
+Confinement.site.rules do |assets:, layouts:, contents:, routes:|
   assets.init("application.js", entrypoint: true)
   assets.init("application.css", entrypoint: false)
 
@@ -204,11 +435,6 @@ Confinement.site.build do |assets:, layouts:, contents:, routes:|
   end
 end
 
-==> write.rb
-require_relative "build"
-
-Confinement::Publish.new(Confinement.site).write
-
 ==> package.json
 {
   "name": "website",

data/lib/confinement.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
-if Gem.loaded_specs.has_key?("pry-byebug")
-  require "pry-byebug"
-elsif Gem.loaded_specs.has_key?("pry-byebug")
+if Gem.loaded_specs.has_key?("pry")
   require "pry"
 end
 
 # standard library
 require "digest"
+require "logger"
 require "open3"
 require "pathname"
 require "yaml"
@@ -15,6 +14,7 @@ require "yaml"
 # gems
 require "erubi"
 require "erubi/capture_end"
+require "zeitwerk"
 
 # internal
 require_relative "confinement/version"
@@ -76,68 +76,183 @@ module Confinement
 
   using Easier
 
+  module BuilderGetterInitialization
+    def builder_getter(method_name, klass, ivar, new: [])
+      init_parameters = [*new, "&block"].join(", ")
+
+      class_eval(<<~RUBY, __FILE__, __LINE__)
+        def #{method_name}(&block)
+          if #{ivar}
+            if block_given?
+              raise "#{method_name} is already set up"
+            end
+
+            return #{ivar}
+          end
+
+          if !block_given?
+            raise "Can't initialize #{method_name} without block"
+          end
+
+          #{ivar} = #{klass}.new(#{init_parameters})
+          #{ivar}
+        end
+      RUBY
+    end
+  end
+
   class << self
-    attr_reader :root
+    extend BuilderGetterInitialization
+
+    attr_accessor :config
     attr_accessor :site
+    attr_writer :env
 
-    def root=(path)
-      # NOTE: Pathname.new(Pathname.new(".")) == Pathname.new(".")
-      path = Pathname.new(path).expand_path
-      path = path.expand_path
+    def env
+      @env ||= ENV.fetch("CONFINEMENT_ENV", "development")
+    end
+  end
 
-      if !path.exist?
-        raise Error::PathDoesNotExist, "Root path does not exist: #{path}"
+  class Config
+    extend BuilderGetterInitialization
+
+    builder_getter("loader", "ZeitwerkProxy", "@loader")
+    builder_getter("watcher", "WatcherPaths", "@watcher", new: ["root: @root"])
+    builder_getter("compiler", "Config::Compiler", "@compiler", new: ["root: @root"])
+    builder_getter("source", "Config::Source", "@source", new: ["root: @root"])
+
+    def initialize(root:)
+      @root = Pathname.new(root).expand_path.cleanpath
+
+      if !@root.exist?
+        raise Error::PathDoesNotExist, "Root path does not exist: #{@root}"
       end
+    end
+
+    attr_reader :root
+    attr_writer :logger
+
+    def logger
+      @logger ||= default_logger
+    end
 
-      @root = path
+    def default_logger
+      Logger.new($stdout).tap do |l|
+        l.level = Logger::INFO
+      end
+    end
+
+    class ZeitwerkProxy
+      def initialize
+        @loader = Zeitwerk::Loader.new
+        yield(self)
+        @loader.setup
+      end
+
+      def push_dir(dir)
+        @loader.push_dir(dir)
+      end
+
+      def enable_reloading
+        @loader.enable_reloading
+      end
+
+      def reload
+        @loader.reload
+      end
+    end
+
+    class WatcherPaths
+      def initialize(root:)
+        @root = root
+        @assets = []
+        @contents = []
+
+        yield(self)
+
+        @assets = @assets.map { |path| @root.concat(path) }
+        @contents = @contents.map { |path| @root.concat(path) }
+      end
+
+      attr_reader :assets
+      attr_reader :contents
+    end
+
+    class Compiler
+      def initialize(root:)
+        @root = root
+        yield(self)
+
+        self.output_root ||= default_output_root
+      end
+
+      attr_accessor :output_root
+      attr_accessor :output_assets
+      attr_accessor :output_directory_index
+
+      def output_root_path
+        @root.concat(output_root).cleanpath.expand_path
+      end
+
+      def output_assets_path
+        @root.concat(output_root, output_assets).cleanpath.expand_path
+      end
+
+      def default_output_root
+        "tmp/build-#{Confinement.env}"
+      end
+    end
+
+    class Source
+      def initialize(root:)
+        @root = root
+        yield(self)
+      end
+
+      attr_accessor :assets
+      attr_accessor :contents
+      attr_accessor :layouts
+
+      def assets_path
+        @root.concat(assets).cleanpath.expand_path
+      end
+
+      def contents_path
+        @root.concat(contents).cleanpath.expand_path
+      end
+
+      def layouts_path
+        @root.concat(layouts).cleanpath.expand_path
+      end
     end
   end
 
   class Site
-    def initialize(
-      root:,
-      assets:,
-      contents:,
-      layouts:,
-      view_context_helpers: [],
-      guesses: Renderer.guesses,
-      config: {}
-    )
-      @root = root
-      @assets = assets
-      @contents = contents
-      @layouts = layouts
-
-      @view_context_helpers = view_context_helpers
-      @guessing_registry = guesses
-
-      @config = {
-        index: config.fetch(:index, "index.html")
-      }
+    def initialize(config)
+      @root = config.root
+
+      yield(self)
 
-      @output_root = root.concat(config.fetch(:destination_root, "public"))
-      @assets_root = @output_root.concat(config.fetch(:assets_subdirectory, "assets"))
+      @view_context_helpers ||= []
+      @guesses ||= Rendering.guesses
 
       @route_identifiers = RouteIdentifiers.new
-      @asset_blobs = Blobs.new(scoped_root: assets_path, file_abstraction_class: Asset)
-      @content_blobs = Blobs.new(scoped_root: contents_path, file_abstraction_class: Content)
-      @layout_blobs = Blobs.new(scoped_root: layouts_path, file_abstraction_class: Layout)
+      @asset_blobs = Blobs.new(scoped_root: config.source.assets_path, file_abstraction_class: Asset)
+      @content_blobs = Blobs.new(scoped_root: config.source.contents_path, file_abstraction_class: Content)
+      @layout_blobs = Blobs.new(scoped_root: config.source.layouts_path, file_abstraction_class: Layout)
     end
 
     attr_reader :root
-    attr_reader :output_root
-    attr_reader :assets_root
-    attr_reader :config
 
     attr_reader :route_identifiers
     attr_reader :asset_blobs
     attr_reader :content_blobs
     attr_reader :layout_blobs
 
-    attr_reader :view_context_helpers
-    attr_reader :guessing_registry
+    attr_accessor :view_context_helpers
+    attr_accessor :guesses
 
-    def build
+    def rules
       yield(
         assets: @asset_blobs,
         layouts: @layout_blobs,
@@ -145,7 +260,7 @@ module Confinement
         routes: @route_identifiers
       )
 
-      guesser = Rendering::Guesser.new(guessing_registry)
+      guesser = Rendering::Guesser.new(guesses)
       guess_renderers(guesser, @layout_blobs)
       guess_renderers(guesser, @content_blobs)
 
@@ -157,6 +272,18 @@ module Confinement
       nil
     end
 
+    def partial_compilation
+      { asset_blobs: @asset_blobs }
+    end
+
+    def partial_compilation=(previous_partial_compilation)
+      return if previous_partial_compilation.nil?
+
+      @asset_blobs = previous_partial_compilation.fetch(:asset_blobs)
+
+      nil
+    end
+
     private
 
     def guess_renderers(guesser, blobs)
@@ -170,18 +297,6 @@ module Confinement
         end
       end
     end
-
-    def contents_path
-      @contents_path ||= @root.concat(@contents).cleanpath
-    end
-
-    def layouts_path
-      @layouts_path ||= @root.concat(@layouts).cleanpath
-    end
-
-    def assets_path
-      @assets_path ||= @root.concat(@assets).cleanpath
-    end
   end
 
   # RouteIdentifiers is called such because it doesn't hold the actual
@@ -515,49 +630,50 @@ module Confinement
   end
 
   class Compiler
-    def initialize(site)
-      @site = site
-      @lock = Mutex.new
+    def initialize(config)
+      @config = config
+      @logger = config.logger
     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.asset_blobs.send(:lookup))
-        compile_contents(site.route_identifiers.send(:lookup).values)
-      end
+    def compile_everything(site)
+      # Assets first since it's almost always a dependency of contents
+      compile_assets(site)
+      compile_contents(site)
     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(asset_files)
+    def compile_assets(site)
+      @logger.info { "compiling assets" }
+      create_destination_directory
+      asset_files = site.asset_blobs.send(:lookup)
       asset_paths = asset_files.values
 
-      out, status = Open3.capture2(
+      command = [
         "yarn",
         "run",
         "parcel",
         "build",
         "--no-cache",
-        "--dist-dir", site.assets_root.to_s,
-        "--public-url", site.assets_root.basename.to_s,
+        "--dist-dir", @config.compiler.output_assets_path.to_s,
+        "--public-url", @config.compiler.output_assets_path.basename.to_s,
         *asset_paths.select(&:entrypoint?).map(&:input_path).map(&:to_s)
-      )
+      ]
+
+      @logger.debug { "running: #{command.join(" ")}" }
+
+      out, status = Open3.capture2(*command)
 
       if !status.success?
+        @logger.fatal { "asset compilation failed" }
         raise "Asset compilation failed"
       end
 
       matches = PARCEL_FILES_OUTPUT_REGEX.match(out)[1]
 
       if !matches
+        @logger.fatal { "asset compilation ouptut parsing failed" }
         raise "Asset compilation output parsing failed"
       end
 
@@ -566,30 +682,68 @@ module Confinement
       processed_file_paths.map do |file|
         output_file, *input_files = file.strip.split(/\n(?:└|├)── /)
 
-        output_path = site.root.concat(output_file[PARCEL_FILE_OUTPUT_REGEX, 1])
+        output_path = @config.root.concat(output_file[PARCEL_FILE_OUTPUT_REGEX, 1])
 
         input_files.each do |input_file|
-          input_path = site.root.concat(input_file[PARCEL_FILE_OUTPUT_REGEX, 1])
+          input_path = @config.root.concat(input_file[PARCEL_FILE_OUTPUT_REGEX, 1])
 
           if !asset_files.key?(input_path)
             next
           end
 
-          url_path = output_path.relative_path_from(site.output_root)
+          url_path = output_path.relative_path_from(@config.compiler.output_root_path)
+          @logger.debug { "processesd asset: #{input_path}, #{url_path}, #{output_path}" }
           asset_files[input_path].url_path = url_path.to_s
           asset_files[input_path].output_path = output_path
           asset_files[input_path].body = output_path.read
         end
       end
+
+      @logger.info { "finished compiling assets" }
     end
 
-    def compile_contents(contents)
+    def compile_contents(site)
+      @logger.info { "compiling contents" }
+      create_destination_directory
+      contents = site.route_identifiers.send(:lookup).values
       contents.each do |content|
-        compile_content(content)
+        compile_content(site, content)
       end
+      @logger.info { "finished compiling contents" }
     end
 
-    def compile_content(content)
+    def partial_compilation_dirty?(before:, after:)
+      return true if !before.key?(:asset_blobs)
+      return true if !after.key?(:asset_blobs)
+
+      before_assets = before[:asset_blobs].send(:lookup)
+      after_assets = after[:asset_blobs].send(:lookup)
+
+      return true if before_assets.keys.sort != after_assets.keys.sort
+      return true if before_assets.any? { |k, v| v.input_path != after_assets[k].input_path }
+      return true if before_assets.any? { |k, v| v.entrypoint? != after_assets[k].entrypoint? }
+
+      false
+    end
+
+    private
+
+    def create_destination_directory
+      destination = @config.compiler.output_root_path
+
+      if destination.exist?
+        return
+      end
+
+      if !destination.dirname.exist?
+        raise Error::PathDoesNotExist, "Destination's parent path does not exist: #{destination.dirname}"
+      end
+
+      destination.mkpath
+    end
+
+    def compile_content(site, content)
+      @logger.debug { "compiling content: #{content.input_path}, #{content.renderers}" }
       view_context = Rendering::ViewContext.new(
         routes: site.route_identifiers,
         layouts: site.layout_blobs,
@@ -607,9 +761,9 @@ module Confinement
 
       content.output_path =
         if content.url_path[-1] == "/"
-          site.output_root.concat(content.url_path, site.config.fetch(:index))
+          @config.compiler.output_root_path.concat(content.url_path, @config.compiler.output_directory_index)
         else
-          site.output_root.concat(content.url_path)
+          @config.compiler.output_root_path.concat(content.url_path)
         end
 
       if content.output_path.exist?
@@ -618,7 +772,7 @@ module Confinement
         end
       end
 
-      if !site.output_root.include?(content.output_path)
+      if !@config.compiler.output_root_path.include?(content.output_path)
         return
       end
 
@@ -631,29 +785,4 @@ module Confinement
       nil
     end
   end
-
-  class Publish
-    def initialize(site)
-      @site = site
-      @compiler = Compiler.new(@site)
-    end
-
-    def write
-      find_or_raise_or_mkdir(@site.output_root)
-
-      @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/filewatcher/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 - 2018 Thomas Flemming
+
+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/lib/confinement/filewatcher/filewatcher.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative 'filewatcher/cycles'
+
+# Simple file watcher. Detect changes in files and directories.
+#
+# Issues: Currently doesn't monitor changes in directorynames
+class Filewatcher
+  include Filewatcher::Cycles
+
+  attr_accessor :interval
+  attr_reader :keep_watching
+
+  def update_spinner(label)
+    return unless @show_spinner
+    @spinner ||= %w[\\ | / -]
+    print "#{' ' * 30}\r#{label}  #{@spinner.rotate!.first}\r"
+  end
+
+  def initialize(unexpanded_filenames, options = {})
+    @unexpanded_filenames = unexpanded_filenames
+    @unexpanded_excluded_filenames = options[:exclude]
+    @keep_watching = false
+    @pausing = false
+    @immediate = options[:immediate]
+    @show_spinner = options[:spinner]
+    @interval = options.fetch(:interval, 0.5)
+  end
+
+  def watch(&on_update)
+    @on_update = on_update
+    @keep_watching = true
+    yield('', '') if @immediate
+
+    main_cycle
+
+    @end_snapshot = mtime_snapshot
+    finalize(&on_update)
+  ensure
+    stop
+  end
+
+  def pause
+    @pausing = true
+    update_spinner('Initiating pause')
+    # Ensure we wait long enough to enter pause loop in #watch
+    sleep @interval
+  end
+
+  def resume
+    if !@keep_watching || !@pausing
+      raise "Can't resume unless #watch and #pause were first called"
+    end
+    @last_snapshot = mtime_snapshot # resume with fresh snapshot
+    @pausing = false
+    update_spinner('Resuming')
+    sleep @interval # Wait long enough to exit pause loop in #watch
+  end
+
+  # Ends the watch, allowing any remaining changes to be finalized.
+  # Used mainly in multi-threaded situations.
+  def stop
+    @keep_watching = false
+    update_spinner('Stopping')
+    nil
+  end
+
+  # Calls the update block repeatedly until all changes in the
+  # current snapshot are dealt with
+  def finalize(&on_update)
+    on_update = @on_update unless block_given?
+    while filesystem_updated?(@end_snapshot || mtime_snapshot)
+      update_spinner('Finalizing')
+      trigger_changes(on_update)
+    end
+    @end_snapshot = nil
+  end
+
+  def last_found_filenames
+    last_snapshot.keys
+  end
+
+  private
+
+  def last_snapshot
+    @last_snapshot ||= mtime_snapshot
+  end
+
+  # Takes a snapshot of the current status of watched files.
+  # (Allows avoidance of potential race condition during #finalize)
+  def mtime_snapshot
+    snapshot = {}
+    filenames = expand_directories(@unexpanded_filenames)
+
+    # Remove files in the exclude filenames list
+    filenames -= expand_directories(@unexpanded_excluded_filenames)
+
+    filenames.each do |filename|
+      mtime = File.exist?(filename) ? File.mtime(filename) : Time.new(0)
+      snapshot[filename] = mtime
+    end
+    snapshot
+  end
+
+  def filesystem_updated?(snapshot = mtime_snapshot)
+    @changes = {}
+
+    (snapshot.to_a - last_snapshot.to_a).each do |file, _mtime|
+      @changes[file] = last_snapshot[file] ? :updated : :created
+    end
+
+    (last_snapshot.keys - snapshot.keys).each do |file|
+      @changes[file] = :deleted
+    end
+
+    @last_snapshot = snapshot
+    @changes.any?
+  end
+
+  def expand_directories(patterns)
+    patterns = Array(patterns) unless patterns.is_a? Array
+    expanded_patterns = patterns.map do |pattern|
+      pattern = File.expand_path(pattern)
+      Dir[
+        File.directory?(pattern) ? File.join(pattern, '**', '*') : pattern
+      ]
+    end
+    expanded_patterns.flatten!
+    expanded_patterns.uniq!
+    expanded_patterns
+  end
+end
+
+# Require at end of file to not overwrite `Filewatcher` class
+require_relative 'filewatcher/version'

data/lib/confinement/filewatcher/filewatcher/cycles.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Filewatcher
+  # Module for all cycles in `Filewatcher#watch`
+  module Cycles
+    private
+
+    def main_cycle
+      while @keep_watching
+        @end_snapshot = mtime_snapshot if @pausing
+
+        pausing_cycle
+
+        watching_cycle
+
+        # test and clear @changes to prevent yielding the last
+        # changes twice if @keep_watching has just been set to false
+        trigger_changes
+      end
+    end
+
+    def pausing_cycle
+      while @keep_watching && @pausing
+        update_spinner('Pausing')
+        sleep @interval
+      end
+    end
+
+    def watching_cycle
+      while @keep_watching && !filesystem_updated? && !@pausing
+        update_spinner('Watching')
+        sleep @interval
+      end
+    end
+
+    def trigger_changes(on_update = @on_update)
+      thread = Thread.new do
+        on_update.call(@changes.dup)
+        @changes.clear
+      end
+      thread.join
+    end
+  end
+end

data/lib/confinement/filewatcher/filewatcher/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative '../filewatcher'
+
+class Filewatcher
+  VERSION = '1.1.1'.freeze
+end

data/lib/confinement/version.rb

@@ -1,3 +1,3 @@
 module Confinement
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: confinement
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Zach Ahn
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-05 00:00:00.000000000 Z
+date: 2020-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -80,6 +80,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
 description: 
 email:
 - engineering@zachahn.com
@@ -102,6 +144,10 @@ files:
 - confinement.gemspec
 - exe/confinement
 - lib/confinement.rb
+- lib/confinement/filewatcher/LICENSE
+- lib/confinement/filewatcher/filewatcher.rb
+- lib/confinement/filewatcher/filewatcher/cycles.rb
+- lib/confinement/filewatcher/filewatcher/version.rb
 - lib/confinement/version.rb
 homepage: https://github.com/zachahn/confinement
 licenses: