RubyGems - confinement - Versions diffs - 0.0.1 → 0.0.2 - Mend

confinement 0.0.1 → 0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e85abea697c0437610597a3c221c833d97931bace819ba66ebb7c02d48ed6c20
-  data.tar.gz: b611ce215a7c6057fe2e874707e314b0644f7f0732229810127cd7c7702fb572
+  metadata.gz: a991bdb8646d092772f6ae7154bc34c7c89ac4faf8d51822e7b1361ed8f7ec05
+  data.tar.gz: 073003314b979b4bbf03dc3baf487030e6a07199feef361b5addad3928a7b06c
 SHA512:
-  metadata.gz: bdc4a25ecacc5d1c378f589d28cef55e63cfd3bbd6353ba9b1cf2439ae08f7bc219f2f77f2257d4bcf887fb7e85c8a6d659097f4a7052c5e47b72d7727b9cbde
-  data.tar.gz: 17527d0a0f6307a5c2dc2b7b2ae445294c03afe5ffea69f20f3dabd3a6ac0a432181d82a8be7985666e01c875ff03f128aacc7add2a6968bda4770b17512c8a4
+  metadata.gz: 72cffafd98539f4655a039c674d9324e998ef508610bad89f9f6e21a5d06cd158487413b60bdeb6b961d76f338c44013bb4ff9f35ea0733ffba74856f01046d8
+  data.tar.gz: 1d6076cc1b834d0a3bf3cd9fcaee3dc7cabd6e048e3f5dc298a7d201c6b60d44f63f0a5f164378c0a9883d9a19e6c83e422a0b9b07d2727164e6e7f2a2493343

data/Gemfile.lock CHANGED

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    confinement (0.0.1)
+    confinement (0.0.2)
       erubi
 GEM

data/exe/confinement CHANGED

@@ -91,7 +91,7 @@ module Confinement
         root = Pathname.new(argv.first).expand_path
-        templates = DATA.read.split(/^==> /)[1..-1]
+        templates = data.split(/^==> /)[1..-1]
         templates = templates.filter_map do |template|
           path, *body = template.lines
           body = body.join("")
@@ -109,8 +109,6 @@ module Confinement
         end
         Dir.chdir(root) do
-          run(["yarn", "init", "--yes"])
           run(["yarn", "add", "--dev", "parcel@nightly"])
         end
       end
@@ -165,6 +163,11 @@ module Confinement
         /^y/i.match?(answer)
       end
+      def data
+        contents = File.read(__FILE__)
+        contents.split(/^__END__$/)[1]
+      end
     end
   end
 end
@@ -177,7 +180,7 @@ require "confinement"
 Confinement.root = __dir__
-Confinement.site = Confinement::Builder.new(
+Confinement.site = Confinement::Site.new(
   root: Confinement.root,
   assets: "assets",
   contents: "contents",
@@ -190,48 +193,50 @@ Confinement.site = Confinement::Builder.new(
 ==> 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,
-  )
+Confinement.site.build do |assets:, layouts:, contents:, routes:|
+  assets.init("application.js", entrypoint: true)
+  assets.init("application.css", entrypoint: false)
-  dest["/assets/application.css"] = Confinement::Asset.new(
-    input_path: assets.join("application.css"),
-    entrypoint: false,
-  )
-end
+  layouts.init("default.html.erb")
-Confinement.site.layouts do |layouts, dest|
-  dest[layouts.join("default.html.erb")] = Confinement::Layout.new(
-    renderers: [Confinement::Renderer::Erb.new]
-  )
+  routes["/"] = contents.init("index.html.erb") do |content|
+    content.layout = layouts["default.html.erb"]
+  end
 end
 ==> write.rb
 require_relative "build"
-Confinement::Publish
-  .new(Confinement.site)
-  .write(Confinement.root.join("public"))
+Confinement::Publish.new(Confinement.site).write
+==> package.json
+{
+  "name": "website",
+  "version": "1.0.0",
+  "license": "UNLICENSED",
+  "devDependencies": {
+  },
+  "dependencies": {
+  }
+}
 ==> assets/application.js
 import "./application.css";
 ==> assets/application.css
+body { color: blue }
 ==> layouts/default.html.erb
+<!DOCTYPE HTML>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <link rel="stylesheet" href="<%= assets["application.css"].url_path %>" charset="utf-8">
+  </head>
+  <body>
+    <%= yield %>
+  </body>
+</html>
 ==> contents/index.html.erb
+hello!

data/lib/confinement.rb CHANGED

@@ -14,6 +14,7 @@ require "yaml"
 # gems
 require "erubi"
+require "erubi/capture_end"
 # internal
 require_relative "confinement/version"
@@ -58,7 +59,7 @@ module Confinement
         return [{}, self] if matches["frontmatter"].nil?
-        frontmatter = YAML.safe_load(matches["frontmatter"])
+        frontmatter = YAML.load(matches["frontmatter"], symbolize_names: true)
         body = matches["body"] || ""
         body = body.strip if strip
@@ -66,6 +67,10 @@ module Confinement
       rescue ArgumentError
         [{}, self]
       end
+      def normalize_for_route
+        "/#{self}".squeeze("/")
+      end
     end
   end
@@ -88,12 +93,24 @@ module Confinement
     end
   end
-  class Builder
-    def initialize(root:, assets:, contents:, layouts:, config: {})
+  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")
       }
@@ -101,167 +118,204 @@ module Confinement
       @output_root = root.concat(config.fetch(:destination_root, "public"))
       @assets_root = @output_root.concat(config.fetch(:assets_subdirectory, "assets"))
-      @representation = Representation.new
+      @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)
     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
+    attr_reader :route_identifiers
+    attr_reader :asset_blobs
+    attr_reader :content_blobs
+    attr_reader :layout_blobs
-    def layouts_path
-      @layouts_path ||= @root.concat(@layouts)
-    end
+    attr_reader :view_context_helpers
+    attr_reader :guessing_registry
-    def assets_path
-      @assets_path ||= @root.concat(@assets)
-    end
+    def build
+      yield(
+        assets: @asset_blobs,
+        layouts: @layout_blobs,
+        contents: @content_blobs,
+        routes: @route_identifiers
+      )
-    def layouts
-      if !layouts_path.exist?
-        raise PathDoesNotExist, "Layouts path doesn't exist: #{layouts_path}"
-      end
+      guesser = Rendering::Guesser.new(guessing_registry)
+      guess_renderers(guesser, @layout_blobs)
+      guess_renderers(guesser, @content_blobs)
+      @asset_blobs.done!
+      @layout_blobs.done!
+      @content_blobs.done!
+      @route_identifiers.done!
-      yield(layouts_path, @representation.layouts)
+      nil
     end
-    def assets
-      if !assets_path.exist?
-        raise PathDoesNotExist, "Assets path doesn't exist: #{assets_path}"
+    private
+    def guess_renderers(guesser, blobs)
+      blobs.send(:lookup).values.each do |blob|
+        blob.renderers = blob.renderers.flat_map do |renderer|
+          if renderer == :guess
+            guesser.call(blob.input_path)
+          else
+            renderer
+          end
+        end
       end
+    end
-      yield(assets_path, @representation.assets)
+    def contents_path
+      @contents_path ||= @root.concat(@contents).cleanpath
     end
-    def contents
-      if !contents_path.exist?
-        raise PathDoesNotExist, "Contents path doesn't exist: #{contents_path}"
-      end
+    def layouts_path
+      @layouts_path ||= @root.concat(@layouts).cleanpath
+    end
-      yield(contents_path, layouts_path, @representation.contents)
+    def assets_path
+      @assets_path ||= @root.concat(@assets).cleanpath
     end
   end
-  class Representation
-    include Enumerable
+  # RouteIdentifiers is called such because it doesn't hold the actual
+  # content's route. The content's own `url_path` does.
+  #
+  # This is mainly so that assets could be referenced internally with a static
+  # identifier even though it could have a hashed route.
+  class RouteIdentifiers
     def initialize
-      @lookup = {}
-      @layouts_lookup = {}
-      @only_assets = []
-      @only_contents = []
+      self.lookup = {}
+    end
+    def done!
+      @done = true
     end
-    attr_reader :only_assets
-    attr_reader :layouts_lookup
-    attr_reader :only_contents
+    def [](route)
+      route = route.normalize_for_route
-    def fetch(key)
-      if !@lookup.key?(key)
-        raise "Not represented!"
+      if !lookup.key?(route)
+        raise "Route is not defined"
       end
-      @lookup[key]
+      self.lookup[route]
     end
-    def each
-      if !block_given?
-        return enum_for(:each)
-      end
+    def []=(route, content)
+      raise "Can't add more routes after initial setup" if @done
-      @lookup.each do |identifier, page|
-        yield(identifier, page)
+      route = route.normalize_for_route
+      if lookup.key?(route)
+        raise "Route already defined!"
       end
+      content.url_path = route
+      lookup[route] = content
     end
-    def layouts
-      Setter.new(@layouts_lookup) do |path, layout|
-        layout.input_path = path
-      end
+    private
+    attr_accessor :lookup
+  end
+  class Blobs
+    def initialize(scoped_root:, file_abstraction_class:)
+      self.scoped_root = scoped_root
+      self.file_abstraction_class = file_abstraction_class
+      self.lookup = {}
+      @done = false
     end
-    def assets
-      Setter.new(@lookup) do |identifier, asset|
-        @only_assets.push(asset)
-        asset.url_path = identifier
-      end
+    def done!
+      @done = true
     end
-    def contents
-      Setter.new(@lookup) do |identifier, content|
-        @only_contents.push(content)
-        content.url_path = identifier
+    def [](relpath)
+      abspath = into_abspath(relpath)
+      if !lookup.key?(abspath)
+        raise "Don't know about this blob: #{abspath.inspect}"
       end
-    end
-    def routes_getter
-      LookupGetter.new(@lookup)
+      lookup[abspath]
     end
-    def layouts_getter
-      LookupGetter.new(@layouts_lookup)
+    def init(relpath, **initializer_options)
+      raise "Can't add more #{file_abstraction_class}s after the initial setup!" if @done
+      abspath = into_abspath(relpath)
+      lookup[abspath] ||= file_abstraction_class.new(input_path: abspath, **initializer_options)
+      yield lookup[abspath] if block_given?
+      lookup[abspath]
     end
-    class Setter
-      def initialize(lookup, &block)
-        @lookup = lookup
-        @block = block
+    def init_many(pattern)
+      files_lookup.filter_map do |relpath, abspath|
+        if pattern.match?(relpath)
+          lookup[abspath.to_s] ||= file_abstraction_class.new(input_path: abspath)
+        end
       end
+    end
-      def []=(key, value)
-        @block&.call(key, value)
+    private
-        @lookup[key] = value
-      end
+    def into_abspath(relpath)
+      scoped_root.concat(relpath).cleanpath
     end
-    class LookupGetter
-      def initialize(lookup)
-        @lookup = lookup
-      end
-      def [](key)
-        @lookup.fetch(key)
-      end
+    def files_lookup
+      @files_lookup ||=
+        scoped_root
+        .glob("**/*")
+        .map { |path| [path.relative_path_from(scoped_root).to_s, path] }
+        .to_h
     end
+    attr_accessor :scoped_root
+    attr_accessor :file_abstraction_class
+    attr_accessor :lookup
   end
   module Blob
     attr_accessor :input_path
+  end
+  module RouteableBlob
     attr_accessor :output_path
     attr_reader :url_path
-    def url_path=(path)
-      if path.nil?
-        @url_path = nil
-        return
-      end
+    def url_path=(new_url_path)
+      @url_path = new_url_path.normalize_for_route
+    end
+  end
-      path = path.to_s
-      if path[0] != "/"
-        path = "/#{path}"
-      end
+  module RenderableBlob
+    attr_reader :renderers
-      @url_path = path
+    def renderers=(new_renderers)
+      @renderers = Array(new_renderers)
     end
   end
   class Asset
     include Blob
+    include RouteableBlob
     def initialize(input_path:, entrypoint:)
       self.input_path = input_path
       @entrypoint = entrypoint
-      @url_path = nil
     end
-    attr_accessor :rendered_body
+    attr_accessor :body
     def entrypoint?
       !!@entrypoint
@@ -270,48 +324,90 @@ module Confinement
   class Content
     include Blob
+    include RouteableBlob
+    include RenderableBlob
-    def initialize(layout: nil, input_path: nil, locals: {}, renderers: [])
+    def initialize(input_path:, layout: nil, locals: {}, renderers: :guess)
       self.input_path = input_path
-      @layout = layout
-      @locals = locals
-      @renderers = renderers
+      self.layout = layout
+      self.locals = locals
+      self.renderers = renderers
     end
-    attr_reader :locals
-    attr_reader :renderers
-    attr_reader :layout
+    attr_accessor :locals
+    attr_accessor :layout
+    def body
+      parse_body_and_frontmatter
+      @body
+    end
+    def frontmatter
+      parse_body_and_frontmatter
+      @frontmatter
+    end
+    private
-    attr_accessor :rendered_body
+    def parse_body_and_frontmatter
+      return if defined?(@frontmatter) && defined?(@body)
+      @frontmatter, @body = input_path.read.frontmatter_and_body
+    end
   end
   class Layout
-    def initialize(renderers:)
-      @renderers = renderers
+    include Blob
+    include RenderableBlob
+    def initialize(input_path:, renderers: :guess)
+      self.input_path = input_path
+      self.renderers = renderers
     end
-    attr_reader :renderers
-    attr_accessor :input_path
+    def body
+      @body ||= input_path.read
+    end
   end
   class Renderer
+    def self.guesses
+      @guesses ||= {
+        "erb" => -> { Erb.new }
+      }
+    end
     class Erb
-      def call(source, view_context, &block)
-        method_name = "_#{Digest::MD5.hexdigest(source)}"
+      def call(source, view_context, path:, &block)
+        method_name =
+          if path
+            "_#{Digest::MD5.hexdigest(source)}__#{path.to_s.tr("^A-Za-z", "_")}"
+          else
+            "_#{Digest::MD5.hexdigest(source)}"
+          end
-        compile(method_name, source, view_context)
+        compile(method_name, source, view_context, path: path)
         view_context.public_send(method_name, &block)
       end
       private
-      def compile(method_name, source, view_context)
+      def compile(method_name, source, view_context, path:)
         if !view_context.respond_to?(method_name)
-          compiled_erb = Erubi::Engine.new(source).src
+          compiled_erb =
+            Erubi::CaptureEndEngine
+            .new(source, bufvar: :@_buf, ensure: true, yield_returns_buffer: true)
+            .src
+          eval_location =
+            if path
+              [path.to_s, 0]
+            else
+              []
+            end
-          view_context.instance_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          view_context.instance_eval(<<~RUBY, *eval_location)
             def #{method_name}
               #{compiled_erb}
             end
@@ -322,56 +418,73 @@ module Confinement
   end
   class Rendering
+    class Guesser
+      def initialize(guessing_registry)
+        @guessing_registry = guessing_registry
+      end
+      def call(path)
+        basename = path.basename.to_s
+        extensions = basename.split(".")[1..-1]
+        extensions.reverse.filter_map do |extension|
+          next if !@guessing_registry.key?(extension)
+          guess = @guessing_registry[extension]
+          guess = guess.call if guess.is_a?(Proc)
+          guess
+        end
+      end
+    end
     class ViewContext
-      def initialize(routes:, layouts:, locals:, frontmatter:, contents_path:, layouts_path:)
+      def initialize(routes:, layouts:, assets:, contents:, locals:, frontmatter:)
         @routes = routes
         @layouts = layouts
+        @assets = assets
+        @contents = contents
         @locals = locals
         @frontmatter = frontmatter
-        @contents_path = contents_path
-        @layouts_path = layouts_path
       end
       attr_reader :routes
       attr_reader :layouts
+      attr_reader :assets
+      attr_reader :contents
       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
+      def capture
+        original_buffer = @_buf
+        @_buf = +""
+        yield
+        @_buf
+      ensure
+        @_buf = original_buffer
+      end
+      def render(blob, layout: nil, &block)
         render_chain = RenderChain.new(
-          body: body,
-          layout: layout,
-          renderers: renderers,
+          body: blob.body,
+          path: blob.input_path,
+          renderers: blob.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"
+        rendered_body =
+          if block_given?
+            render_chain.call do
+              capture { yield }
             end
+          else
+            render_chain.call
+          end
+        if layout
           layout_render_chain = RenderChain.new(
-            body: layout.input_path.read,
-            layout: nil,
+            body: layout.body,
+            path: layout.input_path,
             renderers: layout.renderers,
             view_context: self
           )
@@ -386,22 +499,22 @@ module Confinement
     end
     class RenderChain
-      def initialize(body:, layout:, renderers:, view_context:)
+      def initialize(body:, path:, renderers:, view_context:)
         @body = body
-        @layout = layout
+        @path = path
         @renderers = renderers
         @view_context = view_context
       end
       def call(&block)
         @renderers.reduce(@body) do |memo, renderer|
-          renderer.call(memo, @view_context, &block)
+          renderer.call(memo, @view_context, path: @path, &block)
         end
       end
     end
   end
-  class HesitantCompiler
+  class Compiler
     def initialize(site)
       @site = site
       @lock = Mutex.new
@@ -414,8 +527,8 @@ module Confinement
       # 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)
+        compile_assets(site.asset_blobs.send(:lookup))
+        compile_contents(site.route_identifiers.send(:lookup).values)
       end
     end
@@ -424,79 +537,73 @@ module Confinement
     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
+    def compile_assets(asset_files)
+      asset_paths = asset_files.values
+      out, status = Open3.capture2(
+        "yarn",
+        "run",
+        "parcel",
+        "build",
+        "--no-cache",
+        "--dist-dir", site.assets_root.to_s,
+        "--public-url", site.assets_root.basename.to_s,
+        *asset_paths.select(&:entrypoint?).map(&:input_path).map(&:to_s)
+      )
-        matches = PARCEL_FILES_OUTPUT_REGEX.match(out)[1]
+      if !status.success?
+        raise "Asset compilation failed"
+      end
-        if !matches
-          raise "Asset parsing failed"
-        end
+      matches = PARCEL_FILES_OUTPUT_REGEX.match(out)[1]
-        processed_file_paths = matches.split("\n\n")
+      if !matches
+        raise "Asset compilation output parsing failed"
+      end
-        representation_by_input_path =
-          site.representation.only_assets.filter_map do |page|
-            next if page.input_path.nil?
+      processed_file_paths = matches.split("\n\n")
-            [page.input_path, page]
-          end
-          .to_h
+      processed_file_paths.map do |file|
+        output_file, *input_files = file.strip.split(/\n(?:└|├)── /)
-        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])
-          output_path = site.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])
-          if !representation_by_input_path.key?(input_path)
+          if !asset_files.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
+          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
     end
-    def compile_content(content)
-      if content.rendered_body
-        return
+    def compile_contents(contents)
+      contents.each do |content|
+        compile_content(content)
       end
+    end
-      content_body = content.input_path.read
-      frontmatter, content_body = content_body.frontmatter_and_body
+    def compile_content(content)
       view_context = Rendering::ViewContext.new(
-        routes: site.representation.routes_getter,
-        layouts: site.representation.layouts_getter,
+        routes: site.route_identifiers,
+        layouts: site.layout_blobs,
+        assets: site.asset_blobs,
+        contents: site.content_blobs,
         locals: content.locals,
-        frontmatter: frontmatter,
-        contents_path: site.contents_path,
-        layouts_path: site.layouts_path
+        frontmatter: content.frontmatter
       )
-      content.rendered_body = view_context.render(
-        inline: content_body,
-        layout: content.layout,
-        renderers: content.renderers
-      )
-      content.rendered_body ||= ""
+      site.view_context_helpers.each do |helper|
+        view_context.extend(helper)
+      end
+      rendered_body = view_context.render(content, layout: content.layout) || ""
       content.output_path =
         if content.url_path[-1] == "/"
@@ -506,7 +613,7 @@ module Confinement
         end
       if content.output_path.exist?
-        if content.output_path.read == content.rendered_body
+        if content.output_path.read == rendered_body
           return
         end
       end
@@ -519,38 +626,20 @@ module Confinement
         content.output_path.dirname.mkpath
       end
-      content.output_path.write(content.rendered_body)
+      content.output_path.write(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)
+      @compiler = Compiler.new(@site)
     end
-    def write(path)
-      find_or_raise_or_mkdir(path)
+    def write
+      find_or_raise_or_mkdir(@site.output_root)
       @compiler.compile_everything
     end

data/lib/confinement/version.rb CHANGED

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

metadata CHANGED

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: confinement
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Zach Ahn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-03-29 00:00:00.000000000 Z
+date: 2020-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler